<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=11"/>
<meta name="generator" content="Doxygen 1.9.4"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Flow: util/basic_blob.hpp Source File</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/searchdata.js"></script>
<script type="text/javascript" src="search/search.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr id="projectrow">
  <td id="projectalign">
   <div id="projectname">Flow<span id="projectnumber">&#160;2.0.0</span>
   </div>
   <div id="projectbrief">Flow project: Full implementation reference.</div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.9.4 -->
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:d3d9a9a6595521f9666a5e94cc830dab83b65699&amp;dn=expat.txt MIT */
var searchBox = new SearchBox("searchBox", "search",'Search','.html');
/* @license-end */
</script>
<script type="text/javascript" src="menudata.js"></script>
<script type="text/javascript" src="menu.js"></script>
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:d3d9a9a6595521f9666a5e94cc830dab83b65699&amp;dn=expat.txt MIT */
$(function() {
  initMenu('',true,false,'search.php','Search');
  $(document).ready(function() { init_search(); });
});
/* @license-end */
</script>
<div id="main-nav"></div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
</div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>

<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="dir_23ec12649285f9fabf3a6b7380226c28.html">util</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="headertitle"><div class="title">basic_blob.hpp</div></div>
</div><!--header-->
<div class="contents">
<a href="basic__blob_8hpp.html">Go to the documentation of this file.</a><div class="fragment"><div class="line"><a id="l00001" name="l00001"></a><span class="lineno">    1</span><span class="comment">/* Flow</span></div>
<div class="line"><a id="l00002" name="l00002"></a><span class="lineno">    2</span><span class="comment"> * Copyright 2023 Akamai Technologies, Inc.</span></div>
<div class="line"><a id="l00003" name="l00003"></a><span class="lineno">    3</span><span class="comment"> *</span></div>
<div class="line"><a id="l00004" name="l00004"></a><span class="lineno">    4</span><span class="comment"> * Licensed under the Apache License, Version 2.0 (the</span></div>
<div class="line"><a id="l00005" name="l00005"></a><span class="lineno">    5</span><span class="comment"> * &quot;License&quot;); you may not use this file except in</span></div>
<div class="line"><a id="l00006" name="l00006"></a><span class="lineno">    6</span><span class="comment"> * compliance with the License.  You may obtain a copy</span></div>
<div class="line"><a id="l00007" name="l00007"></a><span class="lineno">    7</span><span class="comment"> * of the License at</span></div>
<div class="line"><a id="l00008" name="l00008"></a><span class="lineno">    8</span><span class="comment"> *</span></div>
<div class="line"><a id="l00009" name="l00009"></a><span class="lineno">    9</span><span class="comment"> *   https://www.apache.org/licenses/LICENSE-2.0</span></div>
<div class="line"><a id="l00010" name="l00010"></a><span class="lineno">   10</span><span class="comment"> *</span></div>
<div class="line"><a id="l00011" name="l00011"></a><span class="lineno">   11</span><span class="comment"> * Unless required by applicable law or agreed to in</span></div>
<div class="line"><a id="l00012" name="l00012"></a><span class="lineno">   12</span><span class="comment"> * writing, software distributed under the License is</span></div>
<div class="line"><a id="l00013" name="l00013"></a><span class="lineno">   13</span><span class="comment"> * distributed on an &quot;AS IS&quot; BASIS, WITHOUT WARRANTIES OR</span></div>
<div class="line"><a id="l00014" name="l00014"></a><span class="lineno">   14</span><span class="comment"> * CONDITIONS OF ANY KIND, either express or implied.</span></div>
<div class="line"><a id="l00015" name="l00015"></a><span class="lineno">   15</span><span class="comment"> * See the License for the specific language governing</span></div>
<div class="line"><a id="l00016" name="l00016"></a><span class="lineno">   16</span><span class="comment"> * permissions and limitations under the License. */</span></div>
<div class="line"><a id="l00017" name="l00017"></a><span class="lineno">   17</span><span class="comment"></span> </div>
<div class="line"><a id="l00018" name="l00018"></a><span class="lineno">   18</span><span class="comment">/// @file</span></div>
<div class="line"><a id="l00019" name="l00019"></a><span class="lineno">   19</span><span class="comment"></span><span class="preprocessor">#pragma once</span></div>
<div class="line"><a id="l00020" name="l00020"></a><span class="lineno">   20</span> </div>
<div class="line"><a id="l00021" name="l00021"></a><span class="lineno">   21</span><span class="preprocessor">#include &quot;<a class="code" href="blob__fwd_8hpp.html">flow/util/blob_fwd.hpp</a>&quot;</span></div>
<div class="line"><a id="l00022" name="l00022"></a><span class="lineno">   22</span><span class="preprocessor">#include &quot;<a class="code" href="log_8hpp.html">flow/log/log.hpp</a>&quot;</span></div>
<div class="line"><a id="l00023" name="l00023"></a><span class="lineno">   23</span><span class="preprocessor">#include &lt;boost/interprocess/smart_ptr/shared_ptr.hpp&gt;</span></div>
<div class="line"><a id="l00024" name="l00024"></a><span class="lineno">   24</span><span class="preprocessor">#include &lt;boost/move/make_unique.hpp&gt;</span></div>
<div class="line"><a id="l00025" name="l00025"></a><span class="lineno">   25</span><span class="preprocessor">#include &lt;optional&gt;</span></div>
<div class="line"><a id="l00026" name="l00026"></a><span class="lineno">   26</span><span class="preprocessor">#include &lt;limits&gt;</span></div>
<div class="line"><a id="l00027" name="l00027"></a><span class="lineno">   27</span> </div>
<div class="line"><a id="l00028" name="l00028"></a><span class="lineno"><a class="line" href="namespaceflow_1_1util.html">   28</a></span><span class="keyword">namespace </span><a class="code hl_namespace" href="namespaceflow_1_1util.html">flow::util</a></div>
<div class="line"><a id="l00029" name="l00029"></a><span class="lineno">   29</span>{</div>
<div class="line"><a id="l00030" name="l00030"></a><span class="lineno">   30</span><span class="comment"></span> </div>
<div class="line"><a id="l00031" name="l00031"></a><span class="lineno">   31</span><span class="comment">/**</span></div>
<div class="line"><a id="l00032" name="l00032"></a><span class="lineno">   32</span><span class="comment"> * A hand-optimized and API-tweaked replacement for `vector&lt;uint8_t&gt;`, i.e., buffer of bytes inside an allocated area</span></div>
<div class="line"><a id="l00033" name="l00033"></a><span class="lineno">   33</span><span class="comment"> * of equal or larger size; also optionally supports limited garbage-collected memory pool functionality and</span></div>
<div class="line"><a id="l00034" name="l00034"></a><span class="lineno">   34</span><span class="comment"> * SHM-friendly custom-allocator support.</span></div>
<div class="line"><a id="l00035" name="l00035"></a><span class="lineno">   35</span><span class="comment"> *</span></div>
<div class="line"><a id="l00036" name="l00036"></a><span class="lineno">   36</span><span class="comment"> * @see Blob_with_log_context (and especially aliases #Blob and #Sharing_blob), our non-polymorphic sub-class which</span></div>
<div class="line"><a id="l00037" name="l00037"></a><span class="lineno">   37</span><span class="comment"> *      adds some ease of use in exchange for a small perf trade-off.  (More info below under &quot;Logging.&quot;)</span></div>
<div class="line"><a id="l00038" name="l00038"></a><span class="lineno">   38</span><span class="comment"> * @see #Blob_sans_log_context + #Sharing_blob_sans_log_context, each simply an alias to</span></div>
<div class="line"><a id="l00039" name="l00039"></a><span class="lineno">   39</span><span class="comment"> *      `Basic_blob&lt;std::allocator, B&gt;` (with `B = false` or `true` respectively), in a fashion vaguely similar to</span></div>
<div class="line"><a id="l00040" name="l00040"></a><span class="lineno">   40</span><span class="comment"> *      what `string` is to `basic_string` (a little).  This is much like #Blob/#Sharing_blob, in that it is a</span></div>
<div class="line"><a id="l00041" name="l00041"></a><span class="lineno">   41</span><span class="comment"> *      non-template concrete type; but does not take or store a `Logger*`.</span></div>
<div class="line"><a id="l00042" name="l00042"></a><span class="lineno">   42</span><span class="comment"> *</span></div>
<div class="line"><a id="l00043" name="l00043"></a><span class="lineno">   43</span><span class="comment"> * The rationale for its existence mirrors its essential differences from `vector&lt;uint8_t&gt;` which are as follows.</span></div>
<div class="line"><a id="l00044" name="l00044"></a><span class="lineno">   44</span><span class="comment"> * To summarize, though, it exists to guarantee specific performance by reducing implementation uncertainty via</span></div>
<div class="line"><a id="l00045" name="l00045"></a><span class="lineno">   45</span><span class="comment"> * lower-level operations; and force user to explicitly authorize any allocation to ensure thoughtfully performant use.</span></div>
<div class="line"><a id="l00046" name="l00046"></a><span class="lineno">   46</span><span class="comment"> * Update: Plus, it adds non-prefix-sub-buffer feature, which can be useful for zero-copy deserialization.</span></div>
<div class="line"><a id="l00047" name="l00047"></a><span class="lineno">   47</span><span class="comment"> * Update: Plus, it adds a simple form of garbage-collected memory pools, useful for operating multiple `Basic_blob`s</span></div>
<div class="line"><a id="l00048" name="l00048"></a><span class="lineno">   48</span><span class="comment"> * that share a common over-arching memory area (buffer).</span></div>
<div class="line"><a id="l00049" name="l00049"></a><span class="lineno">   49</span><span class="comment"> * Update: Plus, it adds SHM-friendly custom allocator support.  (While all `vector` impls support custom allocators,</span></div>
<div class="line"><a id="l00050" name="l00050"></a><span class="lineno">   50</span><span class="comment"> * only some later versions of gcc `std::vector` work with shared-memory (SHM) allocators and imperfectly at that.</span></div>
<div class="line"><a id="l00051" name="l00051"></a><span class="lineno">   51</span><span class="comment"> * `boost::container::vector` a/k/a `boost::interprocess::vector` is fully SHM-friendly.)</span></div>
<div class="line"><a id="l00052" name="l00052"></a><span class="lineno">   52</span><span class="comment"> *</span></div>
<div class="line"><a id="l00053" name="l00053"></a><span class="lineno">   53</span><span class="comment"> * - It adds a feature over `vector&lt;uint8_t&gt;`: The logical contents `[begin(), end())` can optionally begin</span></div>
<div class="line"><a id="l00054" name="l00054"></a><span class="lineno">   54</span><span class="comment"> *   not at the start of the internally allocated buffer but somewhere past it.  In other words, the logical buffer</span></div>
<div class="line"><a id="l00055" name="l00055"></a><span class="lineno">   55</span><span class="comment"> *   is not necessarily a prefix of the internal allocated buffer.  This feature is critical when one wants</span></div>
<div class="line"><a id="l00056" name="l00056"></a><span class="lineno">   56</span><span class="comment"> *   to use some sub-buffer of a buffer without reallocating a smaller buffer and copying the sub-buffer into it.</span></div>
<div class="line"><a id="l00057" name="l00057"></a><span class="lineno">   57</span><span class="comment"> *   For example, if we read a DATA packet the majority of which is the payload, which begins a few bytes</span></div>
<div class="line"><a id="l00058" name="l00058"></a><span class="lineno">   58</span><span class="comment"> *   from the start -- past a short header -- it may be faster to keep passing around the whole thing with move</span></div>
<div class="line"><a id="l00059" name="l00059"></a><span class="lineno">   59</span><span class="comment"> *   semantics but use only the payload part, after logically</span></div>
<div class="line"><a id="l00060" name="l00060"></a><span class="lineno">   60</span><span class="comment"> *   deserializing it (a/k/a zero-copy deserialization semantics).  Of course</span></div>
<div class="line"><a id="l00061" name="l00061"></a><span class="lineno">   61</span><span class="comment"> *   one can do this with `vector` as well; but one would need to always remember the prefix length even after</span></div>
<div class="line"><a id="l00062" name="l00062"></a><span class="lineno">   62</span><span class="comment"> *   deserializing, at which point such details would be ideally forgotten instead.  So this API is significantly</span></div>
<div class="line"><a id="l00063" name="l00063"></a><span class="lineno">   63</span><span class="comment"> *   more pleasant in that case.  Moreover it can then be used generically more easily, alongside other containers.</span></div>
<div class="line"><a id="l00064" name="l00064"></a><span class="lineno">   64</span><span class="comment"> * - Its performance is guaranteed by internally executing low-level operations such as `memcpy()` directly instead of</span></div>
<div class="line"><a id="l00065" name="l00065"></a><span class="lineno">   65</span><span class="comment"> *   hoping that using a higher-level abstraction will ultimately do the same.</span></div>
<div class="line"><a id="l00066" name="l00066"></a><span class="lineno">   66</span><span class="comment"> *   - In particular, the iterator types exposed by the API *are* pointers instead of introducing any performance</span></div>
<div class="line"><a id="l00067" name="l00067"></a><span class="lineno">   67</span><span class="comment"> *     uncertainty by possibly using wrapper/proxy iterator class.</span></div>
<div class="line"><a id="l00068" name="l00068"></a><span class="lineno">   68</span><span class="comment"> *   - In particular, no element or memory area is *ever* initialized to zero(es) or any other particular filler</span></div>
<div class="line"><a id="l00069" name="l00069"></a><span class="lineno">   69</span><span class="comment"> *     value(s).  (This is surprisingly difficult to avoid with STL containers!  Google it.  Though, e.g.,</span></div>
<div class="line"><a id="l00070" name="l00070"></a><span class="lineno">   70</span><span class="comment"> *     boost.container does provide a `default_init_t` extension to various APIs like `.resize()`.)  If an allocation</span></div>
<div class="line"><a id="l00071" name="l00071"></a><span class="lineno">   71</span><span class="comment"> *     does occur, the area is left as-is unless user specifies a source memory area from which to copy data.</span></div>
<div class="line"><a id="l00072" name="l00072"></a><span class="lineno">   72</span><span class="comment"> *   - Note that I am making no assertion about `vector` being slow; the idea is to guarantee *we* aren&#39;t by removing</span></div>
<div class="line"><a id="l00073" name="l00073"></a><span class="lineno">   73</span><span class="comment"> *     any *question* about it; it&#39;s entirely possible a given `vector` is equally fast, but it cannot be guaranteed by</span></div>
<div class="line"><a id="l00074" name="l00074"></a><span class="lineno">   74</span><span class="comment"> *     standard except in terms of complexity guarantees (which is usually pretty good but not everything).</span></div>
<div class="line"><a id="l00075" name="l00075"></a><span class="lineno">   75</span><span class="comment"> *     - That said a quick story about `std::vector&lt;uint8_t&gt;` (in gcc-8.3 anyway): I (ygoldfel) once used it with</span></div>
<div class="line"><a id="l00076" name="l00076"></a><span class="lineno">   76</span><span class="comment"> *       a custom allocator (which worked in shared memory) and stored a megabytes-long buffer in one.  Its</span></div>
<div class="line"><a id="l00077" name="l00077"></a><span class="lineno">   77</span><span class="comment"> *       destructor, I noticed, spent milliseconds (with 2022 hardware) -- outside the actual dealloc call.</span></div>
<div class="line"><a id="l00078" name="l00078"></a><span class="lineno">   78</span><span class="comment"> *       Reason: It was iterating over every (1-byte) element and invoking its (non-existent/trivial) destructor.  It</span></div>
<div class="line"><a id="l00079" name="l00079"></a><span class="lineno">   79</span><span class="comment"> *       did not specialize to avoid this, intentionally so according to a comment, when using a custom allocator.</span></div>
<div class="line"><a id="l00080" name="l00080"></a><span class="lineno">   80</span><span class="comment"> *       `boost::container::vector&lt;uint8_t&gt;` lacked this problem; but nevertheless it shows generally written</span></div>
<div class="line"><a id="l00081" name="l00081"></a><span class="lineno">   81</span><span class="comment"> *       containers can have hidden such perf quirks.</span></div>
<div class="line"><a id="l00082" name="l00082"></a><span class="lineno">   82</span><span class="comment"> * - To help achieve the previous bullet point, as well as to keep the code simple, the class does not parameterize</span></div>
<div class="line"><a id="l00083" name="l00083"></a><span class="lineno">   83</span><span class="comment"> *   on element type; it stores unsigned bytes, period (though Basic_blob::value_type is good to use if you need to</span></div>
<div class="line"><a id="l00084" name="l00084"></a><span class="lineno">   84</span><span class="comment"> *   refer to that type in code generically).</span></div>
<div class="line"><a id="l00085" name="l00085"></a><span class="lineno">   85</span><span class="comment"> *   Perhaps the same could be achieved by specialization, but we don&#39;t need the parameterization in the first place.</span></div>
<div class="line"><a id="l00086" name="l00086"></a><span class="lineno">   86</span><span class="comment"> * - Unlike `vector`, it has an explicit state where there is no underlying buffer; in this case zero() is `true`.</span></div>
<div class="line"><a id="l00087" name="l00087"></a><span class="lineno">   87</span><span class="comment"> *   Also in that case, `capacity() == 0` and `size() == 0` (and `start() == 0`).  `zero() == true` is the case on</span></div>
<div class="line"><a id="l00088" name="l00088"></a><span class="lineno">   88</span><span class="comment"> *   default-constructed object of this class.  The reason for this is I am never sure, at least, what a</span></div>
<div class="line"><a id="l00089" name="l00089"></a><span class="lineno">   89</span><span class="comment"> *   default-constructed `vector` looks like internally; a null buffer always seemed like a reasonable starting point</span></div>
<div class="line"><a id="l00090" name="l00090"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#af567381736851969f6e8812c54404028">   90</a></span><span class="comment"> *   worth guaranteeing explicitly.</span></div>
<div class="line"><a id="l00091" name="l00091"></a><span class="lineno">   91</span><span class="comment"> * - If `!zero()`:</span></div>
<div class="line"><a id="l00092" name="l00092"></a><span class="lineno">   92</span><span class="comment"> *   - make_zero() deallocates any allocated buffer and ensures zero() is `true`, as if upon default construction.</span></div>
<div class="line"><a id="l00093" name="l00093"></a><span class="lineno">   93</span><span class="comment"> *   - Like `vector`, it keeps an allocated memory chunk of size M, at the start of which is the</span></div>
<div class="line"><a id="l00094" name="l00094"></a><span class="lineno">   94</span><span class="comment"> *     logical buffer of size `N &lt;= M`, where `N == size()`, and `M == capacity()`.  However, `M &gt;= 1` always.</span></div>
<div class="line"><a id="l00095" name="l00095"></a><span class="lineno">   95</span><span class="comment"> *     - There is the aforementioned added feature wherein the logical buffer begins to the right of the allocated</span></div>
<div class="line"><a id="l00096" name="l00096"></a><span class="lineno">   96</span><span class="comment"> *       buffer, namely at index `start()`.  In this case `M &gt;= start() + size()`, and the buffer range</span></div>
<div class="line"><a id="l00097" name="l00097"></a><span class="lineno">   97</span><span class="comment"> *       is in indices `[start(), start() + size())` of the allocated buffer.  By default `start() == 0`, as</span></div>
<div class="line"><a id="l00098" name="l00098"></a><span class="lineno">   98</span><span class="comment"> *       in `vector`, but this can be changed via the 2nd, optional, argument to resize().</span></div>
<div class="line"><a id="l00099" name="l00099"></a><span class="lineno">   99</span><span class="comment"> *   - Like `vector`, `reserve(Mnew)`, with `Mnew &lt;= M`, does nothing.  However, unlike `vector`, the same call is</span></div>
<div class="line"><a id="l00100" name="l00100"></a><span class="lineno">  100</span><span class="comment"> *     *illegal* when `Mnew &gt; M &gt;= 1`.  However, any reserve() call *is* allowed when zero() is `true`.  Therefore,</span></div>
<div class="line"><a id="l00101" name="l00101"></a><span class="lineno">  101</span><span class="comment"> *     if the user is intentionally okay with the performance implications of a reallocation, they can call make_zero()</span></div>
<div class="line"><a id="l00102" name="l00102"></a><span class="lineno">  102</span><span class="comment"> *     and *then* force the reallocating reserve() call.</span></div>
<div class="line"><a id="l00103" name="l00103"></a><span class="lineno">  103</span><span class="comment"> *   - Like `vector`, `resize(Nnew)` merely guarantees post-condition `size() == Nnew`; which means that</span></div>
<div class="line"><a id="l00104" name="l00104"></a><span class="lineno">  104</span><span class="comment"> *     it is essentially equivalent to `reserve(Nnew)` followed by setting internal N member to Nnew.</span></div>
<div class="line"><a id="l00105" name="l00105"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a71eaa4ab6a2673ed34fa8989c47a7bc0">  105</a></span><span class="comment"> *     However, remember that resize() therefore keeps all the behaviors of reserve(), including that it cannot</span></div>
<div class="line"><a id="l00106" name="l00106"></a><span class="lineno">  106</span><span class="comment"> *     grow the buffer (only allocate it when zero() is `true`).</span></div>
<div class="line"><a id="l00107" name="l00107"></a><span class="lineno">  107</span><span class="comment"> *     - If changing `start()` from default, then: `resize(Nnew, Snew)` means `reserve(Nnew + Snew)`, plus saving</span></div>
<div class="line"><a id="l00108" name="l00108"></a><span class="lineno">  108</span><span class="comment"> *       internal N and S members.</span></div>
<div class="line"><a id="l00109" name="l00109"></a><span class="lineno">  109</span><span class="comment"> * - The *only* way to allocate is to (directly or indirectly) call `reserve(Mnew)` when `zero() == true`.</span></div>
<div class="line"><a id="l00110" name="l00110"></a><span class="lineno">  110</span><span class="comment"> *   Moreover, *exactly* Mnew bytes elements are allocated and no more (unlike with `vector`, where the policy used is</span></div>
<div class="line"><a id="l00111" name="l00111"></a><span class="lineno">  111</span><span class="comment"> *   not known).  Moreover, if `reserve(Mnew)` is called indirectly (by another method of the class), `Mnew` arg</span></div>
<div class="line"><a id="l00112" name="l00112"></a><span class="lineno">  112</span><span class="comment"> *   is set to no greater than size necessary to complete the operation (again, by contrast, it is unknown what `vector`</span></div>
<div class="line"><a id="l00113" name="l00113"></a><span class="lineno">  113</span><span class="comment"> *   does w/r/t capacity policy).</span></div>
<div class="line"><a id="l00114" name="l00114"></a><span class="lineno">  114</span><span class="comment"> * - The rest of the API is common-sense but generally kept to only what has been necessary to date,</span></div>
<div class="line"><a id="l00115" name="l00115"></a><span class="lineno">  115</span><span class="comment"> *   in on-demand fashion.</span></div>
<div class="line"><a id="l00116" name="l00116"></a><span class="lineno">  116</span><span class="comment"> *</span></div>
<div class="line"><a id="l00117" name="l00117"></a><span class="lineno">  117</span><span class="comment"> * ### Optional, simple garbage-collected shared ownership functionality ###</span></div>
<div class="line"><a id="l00118" name="l00118"></a><span class="lineno">  118</span><span class="comment"> * The following feature was added quite some time after `Blob` was first introduced and matured.  However it seamlessly</span></div>
<div class="line"><a id="l00119" name="l00119"></a><span class="lineno">  119</span><span class="comment"> * subsumes all of the above basic functionality with full backwards compatibility.  It can also be disabled</span></div>
<div class="line"><a id="l00120" name="l00120"></a><span class="lineno">  120</span><span class="comment"> * (and is by default) by setting #S_SHARING to `false` at compile-time.  (This gains back a little bit of perf</span></div>
<div class="line"><a id="l00121" name="l00121"></a><span class="lineno">  121</span><span class="comment"> * namely by turning an internal `shared_ptr` to `unique_ptr`.)</span></div>
<div class="line"><a id="l00122" name="l00122"></a><span class="lineno">  122</span><span class="comment"> *</span></div>
<div class="line"><a id="l00123" name="l00123"></a><span class="lineno">  123</span><span class="comment"> * The feature itself is simple: Suppose one has a blob A, constructed or otherwise `resize()`d or `reserve()`d</span></div>
<div class="line"><a id="l00124" name="l00124"></a><span class="lineno">  124</span><span class="comment"> * so as to have `zero() == false`; meaning `capacity() &gt;= 1`.  Now suppose one calls the core method of this *pool*</span></div>
<div class="line"><a id="l00125" name="l00125"></a><span class="lineno">  125</span><span class="comment"> * feature: share() which returns a new blob B.  B will have the same exact start(), size(), capacity() -- and,</span></div>
<div class="line"><a id="l00126" name="l00126"></a><span class="lineno">  126</span><span class="comment"> * in fact, the pointer `data() - start()` (i.e., the underlying buffer start pointer, buffer being capacity() long).</span></div>
<div class="line"><a id="l00127" name="l00127"></a><span class="lineno">  127</span><span class="comment"> * That is, B now shares the underlying memory buffer with A.  Normally, that underlying buffer would be deallocated</span></div>
<div class="line"><a id="l00128" name="l00128"></a><span class="lineno">  128</span><span class="comment"> * when either `A.make_zero()` is called, or A is destructed.  Now that it&#39;s shared by A and B, however,</span></div>
<div class="line"><a id="l00129" name="l00129"></a><span class="lineno">  129</span><span class="comment"> * the buffer is deallocated only once make_zero() or destruction occurs for *both* A and B.  That is, there is an</span></div>
<div class="line"><a id="l00130" name="l00130"></a><span class="lineno">  130</span><span class="comment"> * internal (thread-safe) ref-count that must reach 0.</span></div>
<div class="line"><a id="l00131" name="l00131"></a><span class="lineno">  131</span><span class="comment"> *</span></div>
<div class="line"><a id="l00132" name="l00132"></a><span class="lineno">  132</span><span class="comment"> * Both A and B may now again be share()d into further sharing `Basic_blob`s.  This further increments the ref-count of</span></div>
<div class="line"><a id="l00133" name="l00133"></a><span class="lineno">  133</span><span class="comment"> * original buffer; all such `Basic_blob`s C, D, ... must now either make_zero() or destruct, at which point the dealloc</span></div>
<div class="line"><a id="l00134" name="l00134"></a><span class="lineno">  134</span><span class="comment"> * occurs.</span></div>
<div class="line"><a id="l00135" name="l00135"></a><span class="lineno">  135</span><span class="comment"> *</span></div>
<div class="line"><a id="l00136" name="l00136"></a><span class="lineno">  136</span><span class="comment"> * In that way the buffer -- or *pool* -- is *garbage-collected* as a whole, with reserve() (and APIs like resize()</span></div>
<div class="line"><a id="l00137" name="l00137"></a><span class="lineno">  137</span><span class="comment"> * and ctors that call it) initially allocating and setting internal ref-count to 1, share() incrementing it, and</span></div>
<div class="line"><a id="l00138" name="l00138"></a><span class="lineno">  138</span><span class="comment"> * make_zero() and ~Basic_blob() decrementing it (and deallocating when ref-count=0).</span></div>
<div class="line"><a id="l00139" name="l00139"></a><span class="lineno">  139</span><span class="comment"> *</span></div>
<div class="line"><a id="l00140" name="l00140"></a><span class="lineno">  140</span><span class="comment"> * ### Application of shared ownership: Simple pool-of-`Basic_blob`s functionality ###</span></div>
<div class="line"><a id="l00141" name="l00141"></a><span class="lineno">  141</span><span class="comment"> * The other aspect of this feature is its pool-of-`Basic_blob`s application.  All of the sharing `Basic_blob`s A, B,</span></div>
<div class="line"><a id="l00142" name="l00142"></a><span class="lineno">  142</span><span class="comment"> * ... retain all the aforementioned features including the ability to use resize(), start_past_prefix_inc(), etc.,</span></div>
<div class="line"><a id="l00143" name="l00143"></a><span class="lineno">  143</span><span class="comment"> * to control the location of the logical sub-range [begin(), end()) within the underlying buffer (pool).</span></div>
<div class="line"><a id="l00144" name="l00144"></a><span class="lineno">  144</span><span class="comment"> * E.g., suppose A was 10 bytes, with `start() = 0` and `size() = capacity() = 10`; then share() B is also that way.</span></div>
<div class="line"><a id="l00145" name="l00145"></a><span class="lineno">  145</span><span class="comment"> * Now `B.start_past_prefix_inc(5); A.resize(5);` makes it so that A = the 1st 5 bytes of the pool,</span></div>
<div class="line"><a id="l00146" name="l00146"></a><span class="lineno">  146</span><span class="comment"> * B the last 5 bytes (and they don&#39;t overlap -- can even be concurrently modified safely).  In that way A and B</span></div>
<div class="line"><a id="l00147" name="l00147"></a><span class="lineno">  147</span><span class="comment"> * are now independent `Basic_blob`s -- potentially passed, say, to independent TCP-receive calls, each of which reads</span></div>
<div class="line"><a id="l00148" name="l00148"></a><span class="lineno">  148</span><span class="comment"> * up to 5 bytes -- that share an over-arching pool.</span></div>
<div class="line"><a id="l00149" name="l00149"></a><span class="lineno">  149</span><span class="comment"> *</span></div>
<div class="line"><a id="l00150" name="l00150"></a><span class="lineno">  150</span><span class="comment"> * The API share_after_split_left() is a convenience operation that splits a `Basic_blob`&#39;s [begin(), end()) area into</span></div>
<div class="line"><a id="l00151" name="l00151"></a><span class="lineno">  151</span><span class="comment"> * 2 areas of specified length, then returns a new Basic_blob representing the first area in the split and</span></div>
<div class="line"><a id="l00152" name="l00152"></a><span class="lineno">  152</span><span class="comment"> * modifies `*this` to represent the remainder (the 2nd area).  This simply performs the op described in the preceding</span></div>
<div class="line"><a id="l00153" name="l00153"></a><span class="lineno">  153</span><span class="comment"> * paragraph.  share_after_split_right() is similar but acts symmetrically from the right.  Lastly</span></div>
<div class="line"><a id="l00154" name="l00154"></a><span class="lineno">  154</span><span class="comment"> * `share_after_split_equally*()` splits a Basic_blob into several equally-sized (except the last one potentially)</span></div>
<div class="line"><a id="l00155" name="l00155"></a><span class="lineno">  155</span><span class="comment"> * sub-`Basic_blob`s of size N, where N is an arg.  (It can be thought of as just calling `share_after_split_left(N)`</span></div>
<div class="line"><a id="l00156" name="l00156"></a><span class="lineno">  156</span><span class="comment"> * repeatedly, then returning a sequence of the resulting post-split `Basic_blob`s.)</span></div>
<div class="line"><a id="l00157" name="l00157"></a><span class="lineno">  157</span><span class="comment"> *</span></div>
<div class="line"><a id="l00158" name="l00158"></a><span class="lineno">  158</span><span class="comment"> * To summarize: The `share_after_split*()` APIs are useful to divide (potentially progressively) a pool into</span></div>
<div class="line"><a id="l00159" name="l00159"></a><span class="lineno">  159</span><span class="comment"> * non-overlapping `Basic_blob`s within a pool while ensuring the pool continues to exist while `Basic_blob`s refer</span></div>
<div class="line"><a id="l00160" name="l00160"></a><span class="lineno">  160</span><span class="comment"> * to any part of it (but no later).  Meanwhile direct use of share() with resize() and `start_past_prefix*()` allows</span></div>
<div class="line"><a id="l00161" name="l00161"></a><span class="lineno">  161</span><span class="comment"> * for overlapping such sharing `Basic_blob`s.</span></div>
<div class="line"><a id="l00162" name="l00162"></a><span class="lineno">  162</span><span class="comment"> *</span></div>
<div class="line"><a id="l00163" name="l00163"></a><span class="lineno">  163</span><span class="comment"> * Note that deallocation occurs regardless of which areas of that pool the relevant `Basic_blob`s represent,</span></div>
<div class="line"><a id="l00164" name="l00164"></a><span class="lineno">  164</span><span class="comment"> * and whether they overlap or not (and, for that matter, whether they even together comprise the entire pool or</span></div>
<div class="line"><a id="l00165" name="l00165"></a><span class="lineno">  165</span><span class="comment"> * leave &quot;gaps&quot; in-between).  The whole pool is deallocated the moment the last of the co-owning `Basic_blob`s</span></div>
<div class="line"><a id="l00166" name="l00166"></a><span class="lineno">  166</span><span class="comment"> * performs either make_zero() or ~Basic_blob() -- the values of start() and size() at the time are not relevant.</span></div>
<div class="line"><a id="l00167" name="l00167"></a><span class="lineno">  167</span><span class="comment"> *</span></div>
<div class="line"><a id="l00168" name="l00168"></a><span class="lineno">  168</span><span class="comment"> * ### Custom allocator (and SHared Memory) support ###</span></div>
<div class="line"><a id="l00169" name="l00169"></a><span class="lineno">  169</span><span class="comment"> * Like STL containers this one optionally takes a custom allocator type (#Allocator_raw) as a compile-time parameter</span></div>
<div class="line"><a id="l00170" name="l00170"></a><span class="lineno">  170</span><span class="comment"> * instead of using the regular heap (`std::allocator`).  Unlike many STL container implementations, including</span></div>
<div class="line"><a id="l00171" name="l00171"></a><span class="lineno">  171</span><span class="comment"> * at least older `std::vector`, it supports SHM-storing allocators without a constant cross-process vaddr scheme.</span></div>
<div class="line"><a id="l00172" name="l00172"></a><span class="lineno">  172</span><span class="comment"> * (Some do support this but with surprising perf flaws when storing raw integers/bytes.  boost.container `vector`</span></div>
<div class="line"><a id="l00173" name="l00173"></a><span class="lineno">  173</span><span class="comment"> * has solid support but lacks various other properties of Basic_blob.)  While a detailed discussion is outside</span></div>
<div class="line"><a id="l00174" name="l00174"></a><span class="lineno">  174</span><span class="comment"> * our scope here, the main point is internally `*this` stores no raw `value_type*` but rather</span></div>
<div class="line"><a id="l00175" name="l00175"></a><span class="lineno">  175</span><span class="comment"> * `Allocator_raw::pointer` -- which in many cases *is* `value_type*`; but for advanced applications like SHM</span></div>
<div class="line"><a id="l00176" name="l00176"></a><span class="lineno">  176</span><span class="comment"> * it might be a fancy-pointer like `boost::interprocess::offset_ptr&lt;value_type&gt;`.  For general education</span></div>
<div class="line"><a id="l00177" name="l00177"></a><span class="lineno">  177</span><span class="comment"> * check out boost.interprocess docs covering storage of STL containers in SHM.  (However note that the</span></div>
<div class="line"><a id="l00178" name="l00178"></a><span class="lineno">  178</span><span class="comment"> * allocators provided by that library are only one option even for SHM storage alone; e.g., they are stateful,</span></div>
<div class="line"><a id="l00179" name="l00179"></a><span class="lineno">  179</span><span class="comment"> * and often one would like a stateless -- zero-size -- allocator.  Plus there are other limitations to</span></div>
<div class="line"><a id="l00180" name="l00180"></a><span class="lineno">  180</span><span class="comment"> * boost.interprocess SHM support, robust though it is.)</span></div>
<div class="line"><a id="l00181" name="l00181"></a><span class="lineno">  181</span><span class="comment"> *</span></div>
<div class="line"><a id="l00182" name="l00182"></a><span class="lineno">  182</span><span class="comment"> * ### Logging ###</span></div>
<div class="line"><a id="l00183" name="l00183"></a><span class="lineno">  183</span><span class="comment"> * When and if `*this` logs, it is with log::Sev::S_TRACE severity or more verbose.</span></div>
<div class="line"><a id="l00184" name="l00184"></a><span class="lineno">  184</span><span class="comment"> *</span></div>
<div class="line"><a id="l00185" name="l00185"></a><span class="lineno">  185</span><span class="comment"> * Unlike many other Flow API classes this one does not derive from log::Log_context nor take a `Logger*` in</span></div>
<div class="line"><a id="l00186" name="l00186"></a><span class="lineno">  186</span><span class="comment"> * ctor (and store it).  Instead each API method/ctor/function capable of logging takes an optional</span></div>
<div class="line"><a id="l00187" name="l00187"></a><span class="lineno">  187</span><span class="comment"> * (possibly null) log::Logger pointer.  If supplied it&#39;s used by that API alone (with some minor async exceptions).</span></div>
<div class="line"><a id="l00188" name="l00188"></a><span class="lineno">  188</span><span class="comment"> * If you would like more typical Flow-style logging API then use our non-polymorphic sub-class Blob_with_log_context</span></div>
<div class="line"><a id="l00189" name="l00189"></a><span class="lineno">  189</span><span class="comment"> * (more likely aliases #Blob, #Sharing_blob).  However consider the following first.</span></div>
<div class="line"><a id="l00190" name="l00190"></a><span class="lineno">  190</span><span class="comment"> *</span></div>
<div class="line"><a id="l00191" name="l00191"></a><span class="lineno">  191</span><span class="comment"> * Why this design?  Answer:</span></div>
<div class="line"><a id="l00192" name="l00192"></a><span class="lineno">  192</span><span class="comment"> *   - Basic_blob is meant to be lean, both in terms of RAM used and processor cycles spent.  Storing a `Logger*`</span></div>
<div class="line"><a id="l00193" name="l00193"></a><span class="lineno">  193</span><span class="comment"> *     takes some space; and storing it, copying/moving it, etc., takes a little compute.  In a low-level</span></div>
<div class="line"><a id="l00194" name="l00194"></a><span class="lineno">  194</span><span class="comment"> *     API like Basic_blob this is potentially nice to avoid when not actively needed.  (That said the logging</span></div>
<div class="line"><a id="l00195" name="l00195"></a><span class="lineno">  195</span><span class="comment"> *     can be extremely useful when debugging and/or profiling RAM use + allocations.)</span></div>
<div class="line"><a id="l00196" name="l00196"></a><span class="lineno">  196</span><span class="comment"> *     - This isn&#39;t a killer.  The original `Blob` (before Basic_blob existed) stored a `Logger*`, and it was fine.</span></div>
<div class="line"><a id="l00197" name="l00197"></a><span class="lineno">  197</span><span class="comment"> *       However:</span></div>
<div class="line"><a id="l00198" name="l00198"></a><span class="lineno">  198</span><span class="comment"> *   - Storing a `Logger*` is always okay when `*this` itself is stored in regular heap or on the stack.</span></div>
<div class="line"><a id="l00199" name="l00199"></a><span class="lineno">  199</span><span class="comment"> *     However, `*this` itself may be stored in SHM; #Allocator_raw parameterization (see above regarding</span></div>
<div class="line"><a id="l00200" name="l00200"></a><span class="lineno">  200</span><span class="comment"> *     &quot;Custom allocator&quot;) suggests as much (i.e., if the buffer is stored in SHM, we might be too).</span></div>
<div class="line"><a id="l00201" name="l00201"></a><span class="lineno">  201</span><span class="comment"> *     In that case `Logger*` does not, usually, make sense.  As of this writing `Logger` in process 1</span></div>
<div class="line"><a id="l00202" name="l00202"></a><span class="lineno">  202</span><span class="comment"> *     has no relationship with any `Logger` in process 2; and even if the `Logger` were stored in SHM itself,</span></div>
<div class="line"><a id="l00203" name="l00203"></a><span class="lineno">  203</span><span class="comment"> *     `Logger` would need to be supplied via an in-SHM fancy-pointer, not `Logger*`, typically.  The latter is</span></div>
<div class="line"><a id="l00204" name="l00204"></a><span class="lineno">  204</span><span class="comment"> *     a major can of worms and not supported by flow::log in any case as of this writing.</span></div>
<div class="line"><a id="l00205" name="l00205"></a><span class="lineno">  205</span><span class="comment"> *     - Therefore, even if we don&#39;t care about RAM/perf implications of storing `Logger*` with the blob, at least</span></div>
<div class="line"><a id="l00206" name="l00206"></a><span class="lineno">  206</span><span class="comment"> *       in some real applications it makes no sense.</span></div>
<div class="line"><a id="l00207" name="l00207"></a><span class="lineno">  207</span><span class="comment"> *</span></div>
<div class="line"><a id="l00208" name="l00208"></a><span class="lineno">  208</span><span class="comment"> * #Blob/#Sharing_blob provides this support while ensuring #Allocator_raw (no longer a template parameter in its case)</span></div>
<div class="line"><a id="l00209" name="l00209"></a><span class="lineno">  209</span><span class="comment"> * is the vanilla `std::allocator`.  The trade-off is as noted just above.</span></div>
<div class="line"><a id="l00210" name="l00210"></a><span class="lineno">  210</span><span class="comment"> *</span></div>
<div class="line"><a id="l00211" name="l00211"></a><span class="lineno">  211</span><span class="comment"> * ### Thread safety ###</span></div>
<div class="line"><a id="l00212" name="l00212"></a><span class="lineno">  212</span><span class="comment"> * Before share() (or `share_*()`) is called: Essentially: Thread safety is the same as for `vector&lt;uint8_t&gt;`.</span></div>
<div class="line"><a id="l00213" name="l00213"></a><span class="lineno">  213</span><span class="comment"> *</span></div>
<div class="line"><a id="l00214" name="l00214"></a><span class="lineno">  214</span><span class="comment"> * Without `share*()` any two Basic_blob objects refer to separate areas in memory; hence it is safe to access</span></div>
<div class="line"><a id="l00215" name="l00215"></a><span class="lineno">  215</span><span class="comment"> * Basic_blob A concurrently with accessing Basic_blob B in any fashion (read, write).</span></div>
<div class="line"><a id="l00216" name="l00216"></a><span class="lineno">  216</span><span class="comment"> *</span></div>
<div class="line"><a id="l00217" name="l00217"></a><span class="lineno">  217</span><span class="comment"> * However: If 2 `Basic_blob`s A and B co-own a pool, via a `share*()` chain, then concurrent write and read/write</span></div>
<div class="line"><a id="l00218" name="l00218"></a><span class="lineno">  218</span><span class="comment"> * to A and B respectively are thread-safe if and only if their [begin(), end()) ranges don&#39;t overlap.  Otherwise,</span></div>
<div class="line"><a id="l00219" name="l00219"></a><span class="lineno">  219</span><span class="comment"> * naturally, one would be writing to an area while it is being read simultaneously -- not safe.</span></div>
<div class="line"><a id="l00220" name="l00220"></a><span class="lineno">  220</span><span class="comment"> *</span></div>
<div class="line"><a id="l00221" name="l00221"></a><span class="lineno">  221</span><span class="comment"> * Tip: When working in `share*()` mode, exclusive use of `share_after_split*()` is a great way to guarantee no 2</span></div>
<div class="line"><a id="l00222" name="l00222"></a><span class="lineno">  222</span><span class="comment"> * `Basic_blob`s ever overlap.  Meanwhile one must be careful when using share() directly and/or subsequently sliding</span></div>
<div class="line"><a id="l00223" name="l00223"></a><span class="lineno">  223</span><span class="comment"> * the range around via resize(), `start_past_prefix*()`: `A.share()` and A not only (originally) overlap but</span></div>
<div class="line"><a id="l00224" name="l00224"></a><span class="lineno">  224</span><span class="comment"> * simply represent the same area of memory; and resize() and co. can turn a non-overlapping range into an overlapping</span></div>
<div class="line"><a id="l00225" name="l00225"></a><span class="lineno">  225</span><span class="comment"> * one (encroaching on someone else&#39;s &quot;territory&quot; within the pool).</span></div>
<div class="line"><a id="l00226" name="l00226"></a><span class="lineno">  226</span><span class="comment"> *</span></div>
<div class="line"><a id="l00227" name="l00227"></a><span class="lineno">  227</span><span class="comment"> * @todo Write a class template, perhaps `Tight_blob&lt;Allocator, bool&gt;`, which would be identical to Basic_blob</span></div>
<div class="line"><a id="l00228" name="l00228"></a><span class="lineno">  228</span><span class="comment"> * but forego the framing features, namely size() and start(), thus storing only the RAII array pointer data()</span></div>
<div class="line"><a id="l00229" name="l00229"></a><span class="lineno">  229</span><span class="comment"> * and capacity(); rewrite Basic_blob in terms of this `Tight_blob`.  This simple container type has had some demand</span></div>
<div class="line"><a id="l00230" name="l00230"></a><span class="lineno">  230</span><span class="comment"> * in practice, and Basic_blob can and should be cleanly built on top of it (perhaps even as an IS-A subclass).</span></div>
<div class="line"><a id="l00231" name="l00231"></a><span class="lineno">  231</span><span class="comment"> *</span></div>
<div class="line"><a id="l00232" name="l00232"></a><span class="lineno">  232</span><span class="comment"> * @tparam Allocator</span></div>
<div class="line"><a id="l00233" name="l00233"></a><span class="lineno">  233</span><span class="comment"> *         An allocator, with `value_type` equal to our #value_type, per the standard C++1x `Allocator` concept.</span></div>
<div class="line"><a id="l00234" name="l00234"></a><span class="lineno">  234</span><span class="comment"> *         In most uses this shall be left at the default `std::allocator&lt;value_type&gt;` which allocates in</span></div>
<div class="line"><a id="l00235" name="l00235"></a><span class="lineno">  235</span><span class="comment"> *         standard heap (`new[]`, `delete[]`).  A custom allocator may be used instead.  SHM-storing allocators,</span></div>
<div class="line"><a id="l00236" name="l00236"></a><span class="lineno">  236</span><span class="comment"> *         and generally allocators for which `pointer` is not simply `value_type*` but rather a fancy-pointer</span></div>
<div class="line"><a id="l00237" name="l00237"></a><span class="lineno">  237</span><span class="comment"> *         (see cppreference.com) are correctly supported.  (Note this may not be the case for your compiler&#39;s</span></div>
<div class="line"><a id="l00238" name="l00238"></a><span class="lineno">  238</span><span class="comment"> *         `std::vector`.)</span></div>
<div class="line"><a id="l00239" name="l00239"></a><span class="lineno">  239</span><span class="comment"> * @tparam S_SHARING_ALLOWED</span></div>
<div class="line"><a id="l00240" name="l00240"></a><span class="lineno">  240</span><span class="comment"> *         If `true`, share() and all derived methods, plus blobs_sharing(), can be instantiated (invoked in compiled</span></div>
<div class="line"><a id="l00241" name="l00241"></a><span class="lineno">  241</span><span class="comment"> *         code).  If `false` they cannot (`static_assert()` will trip), but the resulting Basic_blob concrete</span></div>
<div class="line"><a id="l00242" name="l00242"></a><span class="lineno">  242</span><span class="comment"> *         class will be slightly more performant (internally, a `shared_ptr` becomes instead a `unique_ptr` which</span></div>
<div class="line"><a id="l00243" name="l00243"></a><span class="lineno">  243</span><span class="comment"> *         means smaller allocations and no ref-count logic invoked).</span></div>
<div class="line"><a id="l00244" name="l00244"></a><span class="lineno">  244</span><span class="comment"> */</span></div>
<div class="line"><a id="l00245" name="l00245"></a><span class="lineno">  245</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l00246" name="l00246"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html">  246</a></span><span class="keyword">class </span><a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a></div>
<div class="line"><a id="l00247" name="l00247"></a><span class="lineno">  247</span>{</div>
<div class="line"><a id="l00248" name="l00248"></a><span class="lineno">  248</span><span class="keyword">public</span>:</div>
<div class="line"><a id="l00249" name="l00249"></a><span class="lineno">  249</span>  <span class="comment">// Types.</span></div>
<div class="line"><a id="l00250" name="l00250"></a><span class="lineno">  250</span><span class="comment"></span> </div>
<div class="line"><a id="l00251" name="l00251"></a><span class="lineno">  251</span><span class="comment">  /// Short-hand for values, which in this case are unsigned bytes.</span></div>
<div class="line"><a id="l00252" name="l00252"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">  252</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a> = <a class="code hl_typedef" href="namespaceflow.html#ae02da22c4a101eaab447511c905e4f32">uint8_t</a>;</div>
<div class="line"><a id="l00253" name="l00253"></a><span class="lineno">  253</span><span class="comment"></span> </div>
<div class="line"><a id="l00254" name="l00254"></a><span class="lineno">  254</span><span class="comment">  /// Type for index into blob or length of blob or sub-blob.</span></div>
<div class="line"><a id="l00255" name="l00255"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">  255</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> = std::size_t;</div>
<div class="line"><a id="l00256" name="l00256"></a><span class="lineno">  256</span><span class="comment"></span> </div>
<div class="line"><a id="l00257" name="l00257"></a><span class="lineno">  257</span><span class="comment">  /// Type for difference of `size_type`s.</span></div>
<div class="line"><a id="l00258" name="l00258"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a614d9cd750d8db928b4d1e045ef15c56">  258</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a614d9cd750d8db928b4d1e045ef15c56">difference_type</a> = std::ptrdiff_t;</div>
<div class="line"><a id="l00259" name="l00259"></a><span class="lineno">  259</span><span class="comment"></span> </div>
<div class="line"><a id="l00260" name="l00260"></a><span class="lineno">  260</span><span class="comment">  /// Type for iterator pointing into a mutable structure of this type.</span></div>
<div class="line"><a id="l00261" name="l00261"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">  261</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a> = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>*;</div>
<div class="line"><a id="l00262" name="l00262"></a><span class="lineno">  262</span><span class="comment"></span> </div>
<div class="line"><a id="l00263" name="l00263"></a><span class="lineno">  263</span><span class="comment">  /// Type for iterator pointing into an immutable structure of this type.</span></div>
<div class="line"><a id="l00264" name="l00264"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">  264</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a> <span class="keyword">const</span> *;</div>
<div class="line"><a id="l00265" name="l00265"></a><span class="lineno">  265</span><span class="comment"></span> </div>
<div class="line"><a id="l00266" name="l00266"></a><span class="lineno">  266</span><span class="comment">  /// Short-hand for the allocator type specified at compile-time.  Its element type is our #value_type.</span></div>
<div class="line"><a id="l00267" name="l00267"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">  267</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a> = Allocator;</div>
<div class="line"><a id="l00268" name="l00268"></a><span class="lineno">  268</span>  <span class="keyword">static_assert</span>(std::is_same_v&lt;typename Allocator_raw::value_type, value_type&gt;,</div>
<div class="line"><a id="l00269" name="l00269"></a><span class="lineno">  269</span>                <span class="stringliteral">&quot;Allocator template param must be of form A&lt;V&gt; where V is our value_type.&quot;</span>);</div>
<div class="line"><a id="l00270" name="l00270"></a><span class="lineno">  270</span><span class="comment"></span> </div>
<div class="line"><a id="l00271" name="l00271"></a><span class="lineno">  271</span><span class="comment">  /// For container compliance (hence the irregular capitalization): pointer to element.</span></div>
<div class="line"><a id="l00272" name="l00272"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#adc55075d7e257e08058eabf5fe06ee33">  272</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#adc55075d7e257e08058eabf5fe06ee33">pointer</a> = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a>;<span class="comment"></span></div>
<div class="line"><a id="l00273" name="l00273"></a><span class="lineno">  273</span><span class="comment">  /// For container compliance (hence the irregular capitalization): pointer to `const` element.</span></div>
<div class="line"><a id="l00274" name="l00274"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ab73d1c26268670495dda161f95d33ec1">  274</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ab73d1c26268670495dda161f95d33ec1">const_pointer</a> = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a>;<span class="comment"></span></div>
<div class="line"><a id="l00275" name="l00275"></a><span class="lineno">  275</span><span class="comment">  /// For container compliance (hence the irregular capitalization): reference to element.</span></div>
<div class="line"><a id="l00276" name="l00276"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a72b010e5051889dd4732facb0b0d2e12">  276</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a72b010e5051889dd4732facb0b0d2e12">reference</a> = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>&amp;;<span class="comment"></span></div>
<div class="line"><a id="l00277" name="l00277"></a><span class="lineno">  277</span><span class="comment">  /// For container compliance (hence the irregular capitalization): reference to `const` element.</span></div>
<div class="line"><a id="l00278" name="l00278"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a8b5a94572c51f89991987ca9f5bcf2b2">  278</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a8b5a94572c51f89991987ca9f5bcf2b2">const_reference</a> = <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>&amp;;<span class="comment"></span></div>
<div class="line"><a id="l00279" name="l00279"></a><span class="lineno">  279</span><span class="comment">  /// For container compliance (hence the irregular capitalization): #Iterator type.</span></div>
<div class="line"><a id="l00280" name="l00280"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ae5feeeb171724712ace3ec667fc0a3e2">  280</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae5feeeb171724712ace3ec667fc0a3e2">iterator</a> = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a>;<span class="comment"></span></div>
<div class="line"><a id="l00281" name="l00281"></a><span class="lineno">  281</span><span class="comment">  /// For container compliance (hence the irregular capitalization): #Const_iterator type.</span></div>
<div class="line"><a id="l00282" name="l00282"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a527a63b2de0a165bb63296935aee954c">  282</a></span><span class="comment"></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a527a63b2de0a165bb63296935aee954c">const_iterator</a> = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a>;</div>
<div class="line"><a id="l00283" name="l00283"></a><span class="lineno">  283</span> </div>
<div class="line"><a id="l00284" name="l00284"></a><span class="lineno">  284</span>  <span class="comment">// Constants.</span></div>
<div class="line"><a id="l00285" name="l00285"></a><span class="lineno">  285</span><span class="comment"></span> </div>
<div class="line"><a id="l00286" name="l00286"></a><span class="lineno">  286</span><span class="comment">  /// Value of template parameter `S_SHARING_ALLOWED` (for generic programming).</span></div>
<div class="line"><a id="l00287" name="l00287"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a67db182946127383fb48d6a1afbdca90">  287</a></span><span class="comment"></span>  <span class="keyword">static</span> <span class="keyword">constexpr</span> <span class="keywordtype">bool</span> <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#a67db182946127383fb48d6a1afbdca90">S_SHARING</a> = S_SHARING_ALLOWED;</div>
<div class="line"><a id="l00288" name="l00288"></a><span class="lineno">  288</span><span class="comment"></span> </div>
<div class="line"><a id="l00289" name="l00289"></a><span class="lineno">  289</span><span class="comment">  /// Special value indicating an unchanged `size_type` value; such as in resize().</span></div>
<div class="line"><a id="l00290" name="l00290"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a7667397ae554e4a9dcb9a3bf1bf33eb8">  290</a></span><span class="comment"></span>  <span class="keyword">static</span> <span class="keyword">constexpr</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#a7667397ae554e4a9dcb9a3bf1bf33eb8">S_UNCHANGED</a> = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a>(-1); <span class="comment">// Same trick as std::string::npos.</span></div>
<div class="line"><a id="l00291" name="l00291"></a><span class="lineno">  291</span><span class="comment"></span> </div>
<div class="line"><a id="l00292" name="l00292"></a><span class="lineno">  292</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00293" name="l00293"></a><span class="lineno">  293</span><span class="comment">   * `true` if #Allocator_raw underlying allocator template is simply `std::allocator`; `false`</span></div>
<div class="line"><a id="l00294" name="l00294"></a><span class="lineno">  294</span><span class="comment">   * otherwise.</span></div>
<div class="line"><a id="l00295" name="l00295"></a><span class="lineno">  295</span><span class="comment">   *</span></div>
<div class="line"><a id="l00296" name="l00296"></a><span class="lineno">  296</span><span class="comment">   * Note that if this is `true`, it may be worth using #Blob/#Sharing_blob, instead of its `Basic_blob&lt;std::allocator&gt;`</span></div>
<div class="line"><a id="l00297" name="l00297"></a><span class="lineno">  297</span><span class="comment">   * super-class; at the cost of a marginally larger RAM footprint (an added `Logger*`) you&#39;ll get a more convenient</span></div>
<div class="line"><a id="l00298" name="l00298"></a><span class="lineno">  298</span><span class="comment">   * set of logging API knobs (namely `Logger*` stored permanently from construction; and there will be no need to</span></div>
<div class="line"><a id="l00299" name="l00299"></a><span class="lineno">  299</span><span class="comment">   * supply it as arg to subsequent APIs when logging is desired).</span></div>
<div class="line"><a id="l00300" name="l00300"></a><span class="lineno">  300</span><span class="comment">   *</span></div>
<div class="line"><a id="l00301" name="l00301"></a><span class="lineno">  301</span><span class="comment">   * ### Implications of #S_IS_VANILLA_ALLOC being `false` ###</span></div>
<div class="line"><a id="l00302" name="l00302"></a><span class="lineno">  302</span><span class="comment">   * This is introduced in our class doc header.  Briefly however:</span></div>
<div class="line"><a id="l00303" name="l00303"></a><span class="lineno">  303</span><span class="comment">   *   - The underlying buffer, if any, and possibly some small aux data shall be allocated</span></div>
<div class="line"><a id="l00304" name="l00304"></a><span class="lineno">  304</span><span class="comment">   *     via #Allocator_raw, not simply the regular heap&#39;s `new[]` and/or `new`.</span></div>
<div class="line"><a id="l00305" name="l00305"></a><span class="lineno">  305</span><span class="comment">   *     - They shall be deallocated, if needed, via #Allocator_raw, not simply the regular heap&#39;s</span></div>
<div class="line"><a id="l00306" name="l00306"></a><span class="lineno">  306</span><span class="comment">   *       `delete[]` and/or `delete`.</span></div>
<div class="line"><a id="l00307" name="l00307"></a><span class="lineno">  307</span><span class="comment">   *   - Because storing a pointer to log::Logger may be meaningless when storing in an area allocated</span></div>
<div class="line"><a id="l00308" name="l00308"></a><span class="lineno">  308</span><span class="comment">   *     by some custom allocators (particularly SHM-heap ones), we shall not auto-TRACE-log on dealloc.</span></div>
<div class="line"><a id="l00309" name="l00309"></a><span class="lineno">  309</span><span class="comment">   *     - This caveat applies only if #S_SHARING is `true`.</span></div>
<div class="line"><a id="l00310" name="l00310"></a><span class="lineno">  310</span><span class="comment">   *</span></div>
<div class="line"><a id="l00311" name="l00311"></a><span class="lineno">  311</span><span class="comment">   * @internal</span></div>
<div class="line"><a id="l00312" name="l00312"></a><span class="lineno">  312</span><span class="comment">   *   - (If #S_SHARING)</span></div>
<div class="line"><a id="l00313" name="l00313"></a><span class="lineno">  313</span><span class="comment">   *     Accordingly the ref-counted buffer pointer #m_buf_ptr shall be a `boost::interprocess::shared_ptr`</span></div>
<div class="line"><a id="l00314" name="l00314"></a><span class="lineno">  314</span><span class="comment">   *     instead of a vanilla `shared_ptr`; the latter may be faster and more full-featured, but it is likely</span></div>
<div class="line"><a id="l00315" name="l00315"></a><span class="lineno">  315</span><span class="comment">   *     to internally store a raw `T*`; we need one that stores an `Allocator_raw::pointer` instead;</span></div>
<div class="line"><a id="l00316" name="l00316"></a><span class="lineno">  316</span><span class="comment">   *     e.g., a fancy-pointer type (like `boost::interprocess::offset_ptr`) when dealing with</span></div>
<div class="line"><a id="l00317" name="l00317"></a><span class="lineno">  317</span><span class="comment">   *     SHM-heaps (typically).</span></div>
<div class="line"><a id="l00318" name="l00318"></a><span class="lineno">  318</span><span class="comment">   *     - If #S_IS_VANILLA_ALLOC is `true`, then we revert to the faster/more-mature/full-featured</span></div>
<div class="line"><a id="l00319" name="l00319"></a><span class="lineno">  319</span><span class="comment">   *       `shared_ptr`.  In particular it is faster (if used with `make_shared()` and similar) by storing</span></div>
<div class="line"><a id="l00320" name="l00320"></a><span class="lineno">  320</span><span class="comment">   *       the user buffer and aux data/ref-count in one contiguously-allocated buffer.</span></div>
<div class="line"><a id="l00321" name="l00321"></a><span class="lineno">  321</span><span class="comment">   *   - (If #S_SHARING is `false`)</span></div>
<div class="line"><a id="l00322" name="l00322"></a><span class="lineno">  322</span><span class="comment">   *     It&#39;s a typical `unique_ptr` template either way (because it supports non-raw-pointer storage out of the</span></div>
<div class="line"><a id="l00323" name="l00323"></a><span class="lineno">  323</span><span class="comment">   *     box) but:</span></div>
<div class="line"><a id="l00324" name="l00324"></a><span class="lineno">  324</span><span class="comment">   *       - A custom deleter is necessary similarly to the above.</span></div>
<div class="line"><a id="l00325" name="l00325"></a><span class="lineno">  325</span><span class="comment">   *         - Its `pointer` member alias crucially causes the `unique_ptr` to store</span></div>
<div class="line"><a id="l00326" name="l00326"></a><span class="lineno">  326</span><span class="comment">   *           an `Allocator_raw::pointer` instead of a `value_type*`.</span></div>
<div class="line"><a id="l00327" name="l00327"></a><span class="lineno">  327</span><span class="comment">   *</span></div>
<div class="line"><a id="l00328" name="l00328"></a><span class="lineno">  328</span><span class="comment">   * See #Buf_ptr doc header regarding the latter two bullet points.</span></div>
<div class="line"><a id="l00329" name="l00329"></a><span class="lineno">  329</span><span class="comment">   */</span></div>
<div class="line"><a id="l00330" name="l00330"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ab79d366c55643022eaf9e0d7378165d7">  330</a></span>  <span class="keyword">static</span> <span class="keyword">constexpr</span> <span class="keywordtype">bool</span> <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#ab79d366c55643022eaf9e0d7378165d7">S_IS_VANILLA_ALLOC</a> = std::is_same_v&lt;Allocator_raw, std::allocator&lt;value_type&gt;&gt;;</div>
<div class="line"><a id="l00331" name="l00331"></a><span class="lineno">  331</span> </div>
<div class="line"><a id="l00332" name="l00332"></a><span class="lineno">  332</span>  <span class="comment">// Constructors/destructor.</span></div>
<div class="line"><a id="l00333" name="l00333"></a><span class="lineno">  333</span><span class="comment"></span> </div>
<div class="line"><a id="l00334" name="l00334"></a><span class="lineno">  334</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00335" name="l00335"></a><span class="lineno">  335</span><span class="comment">   * Constructs blob with `zero() == true`.  Note this means no buffer is allocated.</span></div>
<div class="line"><a id="l00336" name="l00336"></a><span class="lineno">  336</span><span class="comment">   *</span></div>
<div class="line"><a id="l00337" name="l00337"></a><span class="lineno">  337</span><span class="comment">   * @param alloc_raw</span></div>
<div class="line"><a id="l00338" name="l00338"></a><span class="lineno">  338</span><span class="comment">   *        Allocator to copy and store in `*this` for all buffer allocations/deallocations.</span></div>
<div class="line"><a id="l00339" name="l00339"></a><span class="lineno">  339</span><span class="comment">   *        If #Allocator_raw is stateless, then this has size zero, so nothing is copied at runtime,</span></div>
<div class="line"><a id="l00340" name="l00340"></a><span class="lineno">  340</span><span class="comment">   *        and by definition it is to equal `Allocator_raw()`.</span></div>
<div class="line"><a id="l00341" name="l00341"></a><span class="lineno">  341</span><span class="comment">   */</span></div>
<div class="line"><a id="l00342" name="l00342"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#abbd8243321a70378f27b551ff8082619">  342</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#abbd8243321a70378f27b551ff8082619">Basic_blob</a>(<span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a>&amp; alloc_raw = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a>{});</div>
<div class="line"><a id="l00343" name="l00343"></a><span class="lineno">  343</span><span class="comment"></span> </div>
<div class="line"><a id="l00344" name="l00344"></a><span class="lineno">  344</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00345" name="l00345"></a><span class="lineno">  345</span><span class="comment">   * Constructs blob with size() and capacity() equal to the given `size`, and `start() == 0`.  Performance note:</span></div>
<div class="line"><a id="l00346" name="l00346"></a><span class="lineno">  346</span><span class="comment">   * elements are not initialized to zero or any other value.  A new over-arching buffer (pool) is therefore allocated.</span></div>
<div class="line"><a id="l00347" name="l00347"></a><span class="lineno">  347</span><span class="comment">   *</span></div>
<div class="line"><a id="l00348" name="l00348"></a><span class="lineno">  348</span><span class="comment">   * Corner case note: a post-condition is `zero() == (size() == 0)`.  Note, also, that the latter is *not* a universal</span></div>
<div class="line"><a id="l00349" name="l00349"></a><span class="lineno">  349</span><span class="comment">   * invariant (see zero() doc header).</span></div>
<div class="line"><a id="l00350" name="l00350"></a><span class="lineno">  350</span><span class="comment">   *</span></div>
<div class="line"><a id="l00351" name="l00351"></a><span class="lineno">  351</span><span class="comment">   * Formally: If `size &gt;= 1`, then a buffer is allocated; and the internal ownership ref-count is set to 1.</span></div>
<div class="line"><a id="l00352" name="l00352"></a><span class="lineno">  352</span><span class="comment">   *</span></div>
<div class="line"><a id="l00353" name="l00353"></a><span class="lineno">  353</span><span class="comment">   * @param size</span></div>
<div class="line"><a id="l00354" name="l00354"></a><span class="lineno">  354</span><span class="comment">   *        A non-negative desired size.</span></div>
<div class="line"><a id="l00355" name="l00355"></a><span class="lineno">  355</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00356" name="l00356"></a><span class="lineno">  356</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) or asynchronously when TRACE-logging</span></div>
<div class="line"><a id="l00357" name="l00357"></a><span class="lineno">  357</span><span class="comment">   *        in the event of buffer dealloc.  Null allowed.</span></div>
<div class="line"><a id="l00358" name="l00358"></a><span class="lineno">  358</span><span class="comment">   * @param alloc_raw</span></div>
<div class="line"><a id="l00359" name="l00359"></a><span class="lineno">  359</span><span class="comment">   *        Allocator to copy and store in `*this` for all buffer allocations/deallocations.</span></div>
<div class="line"><a id="l00360" name="l00360"></a><span class="lineno">  360</span><span class="comment">   *        If #Allocator_raw is stateless, then this has size zero, so nothing is copied at runtime,</span></div>
<div class="line"><a id="l00361" name="l00361"></a><span class="lineno">  361</span><span class="comment">   *        and by definition it is to equal `Allocator_raw()`.</span></div>
<div class="line"><a id="l00362" name="l00362"></a><span class="lineno">  362</span><span class="comment">   */</span></div>
<div class="line"><a id="l00363" name="l00363"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a625734b39e0e3317aa321b6f8569f334">  363</a></span>  <span class="keyword">explicit</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a625734b39e0e3317aa321b6f8569f334">Basic_blob</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">size</a>, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>,</div>
<div class="line"><a id="l00364" name="l00364"></a><span class="lineno">  364</span>                      <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a>&amp; alloc_raw = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a>{});</div>
<div class="line"><a id="l00365" name="l00365"></a><span class="lineno">  365</span><span class="comment"></span> </div>
<div class="line"><a id="l00366" name="l00366"></a><span class="lineno">  366</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00367" name="l00367"></a><span class="lineno">  367</span><span class="comment">   * Move constructor, constructing a blob exactly internally equal to pre-call `moved_src`, while the latter is</span></div>
<div class="line"><a id="l00368" name="l00368"></a><span class="lineno">  368</span><span class="comment">   * made to be exactly as if it were just constructed as `Basic_blob(nullptr)` (allocator subtleties aside).</span></div>
<div class="line"><a id="l00369" name="l00369"></a><span class="lineno">  369</span><span class="comment">   * Performance: constant-time, at most copying a few scalars.</span></div>
<div class="line"><a id="l00370" name="l00370"></a><span class="lineno">  370</span><span class="comment">   *</span></div>
<div class="line"><a id="l00371" name="l00371"></a><span class="lineno">  371</span><span class="comment">   * @param moved_src</span></div>
<div class="line"><a id="l00372" name="l00372"></a><span class="lineno">  372</span><span class="comment">   *        The object whose internals to move to `*this` and replace with a blank-constructed object&#39;s internals.</span></div>
<div class="line"><a id="l00373" name="l00373"></a><span class="lineno">  373</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00374" name="l00374"></a><span class="lineno">  374</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00375" name="l00375"></a><span class="lineno">  375</span><span class="comment">   */</span></div>
<div class="line"><a id="l00376" name="l00376"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a477ff0db26f79989d75da4dbe4bf4982">  376</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a477ff0db26f79989d75da4dbe4bf4982">Basic_blob</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp;&amp; moved_src, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00377" name="l00377"></a><span class="lineno">  377</span><span class="comment"></span> </div>
<div class="line"><a id="l00378" name="l00378"></a><span class="lineno">  378</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00379" name="l00379"></a><span class="lineno">  379</span><span class="comment">   * Copy constructor, constructing a blob logically equal to `src`.  More formally, guarantees post-condition wherein</span></div>
<div class="line"><a id="l00380" name="l00380"></a><span class="lineno">  380</span><span class="comment">   * `[this-&gt;begin(), this-&gt;end())` range is equal by value (including length) to `src` equivalent range but no memory</span></div>
<div class="line"><a id="l00381" name="l00381"></a><span class="lineno">  381</span><span class="comment">   * overlap.  A post-condition is `capacity() == size()`, and `start() == 0`.  Performance: see copying assignment</span></div>
<div class="line"><a id="l00382" name="l00382"></a><span class="lineno">  382</span><span class="comment">   * operator.</span></div>
<div class="line"><a id="l00383" name="l00383"></a><span class="lineno">  383</span><span class="comment">   *</span></div>
<div class="line"><a id="l00384" name="l00384"></a><span class="lineno">  384</span><span class="comment">   * Corner case note: the range equality guarantee includes the degenerate case where that range is empty, meaning we</span></div>
<div class="line"><a id="l00385" name="l00385"></a><span class="lineno">  385</span><span class="comment">   * simply guarantee post-condition `src.empty() == this-&gt;empty()`.</span></div>
<div class="line"><a id="l00386" name="l00386"></a><span class="lineno">  386</span><span class="comment">   *</span></div>
<div class="line"><a id="l00387" name="l00387"></a><span class="lineno">  387</span><span class="comment">   * Corner case note 2: post-condition: `this-&gt;zero() == this-&gt;empty()`</span></div>
<div class="line"><a id="l00388" name="l00388"></a><span class="lineno">  388</span><span class="comment">   * (note `src.zero()` state is not necessarily preserved in `*this`).</span></div>
<div class="line"><a id="l00389" name="l00389"></a><span class="lineno">  389</span><span class="comment">   *</span></div>
<div class="line"><a id="l00390" name="l00390"></a><span class="lineno">  390</span><span class="comment">   * Note: This is `explicit`, which is atypical for a copy constructor, to generate compile errors in hard-to-see</span></div>
<div class="line"><a id="l00391" name="l00391"></a><span class="lineno">  391</span><span class="comment">   * (and often unintentional) instances of copying.  Copies of Basic_blob should be quite intentional and explicit.</span></div>
<div class="line"><a id="l00392" name="l00392"></a><span class="lineno">  392</span><span class="comment">   * (One example where one might forget about a copy would be when using a Basic_blob argument without `cref` or</span></div>
<div class="line"><a id="l00393" name="l00393"></a><span class="lineno">  393</span><span class="comment">   * `ref` in a `bind()`; or when capturing by value, not by ref, in a lambda.)</span></div>
<div class="line"><a id="l00394" name="l00394"></a><span class="lineno">  394</span><span class="comment">   *</span></div>
<div class="line"><a id="l00395" name="l00395"></a><span class="lineno">  395</span><span class="comment">   * Formally: If `src.size() &gt;= 1`, then a buffer is allocated; and the internal ownership ref-count is set to 1.</span></div>
<div class="line"><a id="l00396" name="l00396"></a><span class="lineno">  396</span><span class="comment">   *</span></div>
<div class="line"><a id="l00397" name="l00397"></a><span class="lineno">  397</span><span class="comment">   * @param src</span></div>
<div class="line"><a id="l00398" name="l00398"></a><span class="lineno">  398</span><span class="comment">   *        Object whose range of bytes of length `src.size()` starting at `src.begin()` is copied into `*this`.</span></div>
<div class="line"><a id="l00399" name="l00399"></a><span class="lineno">  399</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00400" name="l00400"></a><span class="lineno">  400</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) or asynchronously when TRACE-logging</span></div>
<div class="line"><a id="l00401" name="l00401"></a><span class="lineno">  401</span><span class="comment">   *        in the event of buffer dealloc.  Null allowed.</span></div>
<div class="line"><a id="l00402" name="l00402"></a><span class="lineno">  402</span><span class="comment">   */</span></div>
<div class="line"><a id="l00403" name="l00403"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a3568f40cab930beabf5bd831489d610a">  403</a></span>  <span class="keyword">explicit</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a3568f40cab930beabf5bd831489d610a">Basic_blob</a>(<span class="keyword">const</span> <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; src, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00404" name="l00404"></a><span class="lineno">  404</span><span class="comment"></span> </div>
<div class="line"><a id="l00405" name="l00405"></a><span class="lineno">  405</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00406" name="l00406"></a><span class="lineno">  406</span><span class="comment">   * Destructor that drops `*this` ownership of the allocated internal buffer if any, as by make_zero();</span></div>
<div class="line"><a id="l00407" name="l00407"></a><span class="lineno">  407</span><span class="comment">   * if no other Basic_blob holds ownership of that buffer, then that buffer is deallocated also.</span></div>
<div class="line"><a id="l00408" name="l00408"></a><span class="lineno">  408</span><span class="comment">   * Recall that other `Basic_blob`s can only gain co-ownership via `share*()`; hence if one does not use that</span></div>
<div class="line"><a id="l00409" name="l00409"></a><span class="lineno">  409</span><span class="comment">   * feature, the destructor will in fact deallocate the buffer (if any).</span></div>
<div class="line"><a id="l00410" name="l00410"></a><span class="lineno">  410</span><span class="comment">   *</span></div>
<div class="line"><a id="l00411" name="l00411"></a><span class="lineno">  411</span><span class="comment">   * Formally: If `!zero()`, then the internal ownership ref-count is decremented by 1, and if it reaches</span></div>
<div class="line"><a id="l00412" name="l00412"></a><span class="lineno">  412</span><span class="comment">   * 0, then a buffer is deallocated.</span></div>
<div class="line"><a id="l00413" name="l00413"></a><span class="lineno">  413</span><span class="comment">   *</span></div>
<div class="line"><a id="l00414" name="l00414"></a><span class="lineno">  414</span><span class="comment">   * ### Logging ###</span></div>
<div class="line"><a id="l00415" name="l00415"></a><span class="lineno">  415</span><span class="comment">   * This will not log, as it is not possible to pass a `Logger*` to a dtor without storing it (which we avoid</span></div>
<div class="line"><a id="l00416" name="l00416"></a><span class="lineno">  416</span><span class="comment">   * for reasons outlined in class doc header).  Use #Blob/#Sharing_blob if it is important to log in this situation</span></div>
<div class="line"><a id="l00417" name="l00417"></a><span class="lineno">  417</span><span class="comment">   * (although there are some minor trade-offs).</span></div>
<div class="line"><a id="l00418" name="l00418"></a><span class="lineno">  418</span><span class="comment">   */</span></div>
<div class="line"><a id="l00419" name="l00419"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ae9fc395523fae83128888d9bb1c90726">  419</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ae9fc395523fae83128888d9bb1c90726">~Basic_blob</a>();</div>
<div class="line"><a id="l00420" name="l00420"></a><span class="lineno">  420</span> </div>
<div class="line"><a id="l00421" name="l00421"></a><span class="lineno">  421</span>  <span class="comment">// Methods.</span></div>
<div class="line"><a id="l00422" name="l00422"></a><span class="lineno">  422</span><span class="comment"></span> </div>
<div class="line"><a id="l00423" name="l00423"></a><span class="lineno">  423</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00424" name="l00424"></a><span class="lineno">  424</span><span class="comment">   * Move assignment.  Allocator subtleties aside and assuming `this != &amp;moved_src` it is equivalent to:</span></div>
<div class="line"><a id="l00425" name="l00425"></a><span class="lineno">  425</span><span class="comment">   * `make_zero(); this-&gt;swap(moved_src, logger_ptr)`.  (If `this == &amp;moved_src`, this is a no-op.)</span></div>
<div class="line"><a id="l00426" name="l00426"></a><span class="lineno">  426</span><span class="comment">   *</span></div>
<div class="line"><a id="l00427" name="l00427"></a><span class="lineno">  427</span><span class="comment">   * @param moved_src</span></div>
<div class="line"><a id="l00428" name="l00428"></a><span class="lineno">  428</span><span class="comment">   *        See swap().</span></div>
<div class="line"><a id="l00429" name="l00429"></a><span class="lineno">  429</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00430" name="l00430"></a><span class="lineno">  430</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00431" name="l00431"></a><span class="lineno">  431</span><span class="comment">   * @return `*this`.</span></div>
<div class="line"><a id="l00432" name="l00432"></a><span class="lineno">  432</span><span class="comment">   */</span></div>
<div class="line"><a id="l00433" name="l00433"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a77785988abe56d62dacf42ec6a733713">  433</a></span>  <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a77785988abe56d62dacf42ec6a733713">assign</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp;&amp; moved_src, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00434" name="l00434"></a><span class="lineno">  434</span><span class="comment"></span> </div>
<div class="line"><a id="l00435" name="l00435"></a><span class="lineno">  435</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00436" name="l00436"></a><span class="lineno">  436</span><span class="comment">   * Move assignment operator (no logging): equivalent to `assign(std::move(moved_src), nullptr)`.</span></div>
<div class="line"><a id="l00437" name="l00437"></a><span class="lineno">  437</span><span class="comment">   *</span></div>
<div class="line"><a id="l00438" name="l00438"></a><span class="lineno">  438</span><span class="comment">   * @param moved_src</span></div>
<div class="line"><a id="l00439" name="l00439"></a><span class="lineno">  439</span><span class="comment">   *        See assign() (move overload).</span></div>
<div class="line"><a id="l00440" name="l00440"></a><span class="lineno">  440</span><span class="comment">   * @return `*this`.</span></div>
<div class="line"><a id="l00441" name="l00441"></a><span class="lineno">  441</span><span class="comment">   */</span></div>
<div class="line"><a id="l00442" name="l00442"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a151d35b3c35219089d53061503841b75">  442</a></span>  <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a151d35b3c35219089d53061503841b75">operator=</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp;&amp; moved_src);</div>
<div class="line"><a id="l00443" name="l00443"></a><span class="lineno">  443</span><span class="comment"></span> </div>
<div class="line"><a id="l00444" name="l00444"></a><span class="lineno">  444</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00445" name="l00445"></a><span class="lineno">  445</span><span class="comment">   * Copy assignment: assuming `(this != &amp;src) &amp;&amp; (!blobs_sharing(*this, src))`,</span></div>
<div class="line"><a id="l00446" name="l00446"></a><span class="lineno">  446</span><span class="comment">   * makes `*this` logically equal to `src`; but behavior undefined if a reallocation would be necessary to do this.</span></div>
<div class="line"><a id="l00447" name="l00447"></a><span class="lineno">  447</span><span class="comment">   * (If `this == &amp;src`, this is a no-op.  If not but `blobs_sharing(*this, src) == true`, see &quot;Sharing blobs&quot; below.</span></div>
<div class="line"><a id="l00448" name="l00448"></a><span class="lineno">  448</span><span class="comment">   * This is assumed to not be the case in further discussion.)</span></div>
<div class="line"><a id="l00449" name="l00449"></a><span class="lineno">  449</span><span class="comment">   *</span></div>
<div class="line"><a id="l00450" name="l00450"></a><span class="lineno">  450</span><span class="comment">   * More formally:</span></div>
<div class="line"><a id="l00451" name="l00451"></a><span class="lineno">  451</span><span class="comment">   * no-op if `this == &amp;src`; &quot;Sharing blobs&quot; behavior if not so, but `src` shares buffer with `*this`; otherwise:</span></div>
<div class="line"><a id="l00452" name="l00452"></a><span class="lineno">  452</span><span class="comment">   * Guarantees post-condition wherein `[this-&gt;begin(), this-&gt;end())` range is equal</span></div>
<div class="line"><a id="l00453" name="l00453"></a><span class="lineno">  453</span><span class="comment">   * by value (including length) to `src` equivalent range but no memory overlap.  Post-condition: `start() == 0`;</span></div>
<div class="line"><a id="l00454" name="l00454"></a><span class="lineno">  454</span><span class="comment">   * capacity() either does not change or equals size().  capacity() growth is not allowed: behavior is undefined if</span></div>
<div class="line"><a id="l00455" name="l00455"></a><span class="lineno">  455</span><span class="comment">   * `src.size()` exceeds pre-call `this-&gt;capacity()`, unless `this-&gt;zero() == true` pre-call.  Performance: at most a</span></div>
<div class="line"><a id="l00456" name="l00456"></a><span class="lineno">  456</span><span class="comment">   * memory area of size `src.size()` is copied and some scalars updated; a memory area of that size is allocated only</span></div>
<div class="line"><a id="l00457" name="l00457"></a><span class="lineno">  457</span><span class="comment">   * if required; no ownership drop or deallocation occurs.</span></div>
<div class="line"><a id="l00458" name="l00458"></a><span class="lineno">  458</span><span class="comment">   *</span></div>
<div class="line"><a id="l00459" name="l00459"></a><span class="lineno">  459</span><span class="comment">   * Corner case note: the range equality guarantee includes the degenerate case where that range is empty, meaning we</span></div>
<div class="line"><a id="l00460" name="l00460"></a><span class="lineno">  460</span><span class="comment">   * simply guarantee post-condition `src.empty() == this-&gt;empty()`.</span></div>
<div class="line"><a id="l00461" name="l00461"></a><span class="lineno">  461</span><span class="comment">   *</span></div>
<div class="line"><a id="l00462" name="l00462"></a><span class="lineno">  462</span><span class="comment">   * Corner case note 2: post-condition: if `this-&gt;empty() == true` then `this.zero()` has the same value as at entry</span></div>
<div class="line"><a id="l00463" name="l00463"></a><span class="lineno">  463</span><span class="comment">   * to this call.  In other words, no deallocation occurs, even if</span></div>
<div class="line"><a id="l00464" name="l00464"></a><span class="lineno">  464</span><span class="comment">   * `this-&gt;empty() == true` post-condition holds; at most internally a scalar storing size is assigned 0.</span></div>
<div class="line"><a id="l00465" name="l00465"></a><span class="lineno">  465</span><span class="comment">   * (You may force deallocation in that case via make_zero() post-call, but this means you&#39;ll have to intentionally</span></div>
<div class="line"><a id="l00466" name="l00466"></a><span class="lineno">  466</span><span class="comment">   * perform that relatively slow op.)</span></div>
<div class="line"><a id="l00467" name="l00467"></a><span class="lineno">  467</span><span class="comment">   *</span></div>
<div class="line"><a id="l00468" name="l00468"></a><span class="lineno">  468</span><span class="comment">   * As with reserve(), IF pre-condition `zero() == false`, THEN pre-condition `src.size() &lt;= this-&gt;capacity()`</span></div>
<div class="line"><a id="l00469" name="l00469"></a><span class="lineno">  469</span><span class="comment">   * must hold, or behavior is undefined (i.e., as noted above, capacity() growth is not allowed except from 0).</span></div>
<div class="line"><a id="l00470" name="l00470"></a><span class="lineno">  470</span><span class="comment">   * Therefore, NO REallocation occurs!  However, also as with reserve(), if you want to intentionally allow such a</span></div>
<div class="line"><a id="l00471" name="l00471"></a><span class="lineno">  471</span><span class="comment">   * REallocation, then simply first call make_zero(); then execute the</span></div>
<div class="line"><a id="l00472" name="l00472"></a><span class="lineno">  472</span><span class="comment">   * `assign()` copy as planned.  This is an intentional restriction forcing caller to explicitly allow a relatively</span></div>
<div class="line"><a id="l00473" name="l00473"></a><span class="lineno">  473</span><span class="comment">   * slow reallocation op.</span></div>
<div class="line"><a id="l00474" name="l00474"></a><span class="lineno">  474</span><span class="comment">   *</span></div>
<div class="line"><a id="l00475" name="l00475"></a><span class="lineno">  475</span><span class="comment">   * Formally: If `src.size() &gt;= 1`, and `zero() == true`, then a buffer is allocated; and the internal ownership</span></div>
<div class="line"><a id="l00476" name="l00476"></a><span class="lineno">  476</span><span class="comment">   * ref-count is set to 1.</span></div>
<div class="line"><a id="l00477" name="l00477"></a><span class="lineno">  477</span><span class="comment">   *</span></div>
<div class="line"><a id="l00478" name="l00478"></a><span class="lineno">  478</span><span class="comment">   * ### Sharing blobs ###</span></div>
<div class="line"><a id="l00479" name="l00479"></a><span class="lineno">  479</span><span class="comment">   * If `blobs_sharing(*this, src) == true`, meaning the target and source are operating on the same buffer, then</span></div>
<div class="line"><a id="l00480" name="l00480"></a><span class="lineno">  480</span><span class="comment">   * behavior is undefined (assertion may trip).  Rationale for this design is as follows.  The possibilities were:</span></div>
<div class="line"><a id="l00481" name="l00481"></a><span class="lineno">  481</span><span class="comment">   *   -# Undefined behavior/assertion.</span></div>
<div class="line"><a id="l00482" name="l00482"></a><span class="lineno">  482</span><span class="comment">   *   -# Just adjust `this-&gt;start()` and `this-&gt;size()` to match `src`; continue co-owning the underlying buffer;</span></div>
<div class="line"><a id="l00483" name="l00483"></a><span class="lineno">  483</span><span class="comment">   *      copy no data.</span></div>
<div class="line"><a id="l00484" name="l00484"></a><span class="lineno">  484</span><span class="comment">   *   -# `this-&gt;make_zero()` -- losing `*this` ownership, while `src` keeps it -- and then allocate a new buffer</span></div>
<div class="line"><a id="l00485" name="l00485"></a><span class="lineno">  485</span><span class="comment">   *      and copy `src` data into it.</span></div>
<div class="line"><a id="l00486" name="l00486"></a><span class="lineno">  486</span><span class="comment">   *</span></div>
<div class="line"><a id="l00487" name="l00487"></a><span class="lineno">  487</span><span class="comment">   * Choosing between these is tough, as this is an odd corner case.  3 is not criminal, but generally no method</span></div>
<div class="line"><a id="l00488" name="l00488"></a><span class="lineno">  488</span><span class="comment">   * ever forces make_zero() behavior, always leaving it to the user to consciously do, so it seems prudent to keep</span></div>
<div class="line"><a id="l00489" name="l00489"></a><span class="lineno">  489</span><span class="comment">   * to that practice (even though this case is a bit different from, say, resize() -- since make_zero() here has</span></div>
<div class="line"><a id="l00490" name="l00490"></a><span class="lineno">  490</span><span class="comment">   * no chance to deallocate anything, only decrement ref-count).  2 is performant and slick but suggests a special</span></div>
<div class="line"><a id="l00491" name="l00491"></a><span class="lineno">  491</span><span class="comment">   * behavior in a corner case; this *feels* slightly ill-advised in a standard copy assignment operator.  Therefore</span></div>
<div class="line"><a id="l00492" name="l00492"></a><span class="lineno">  492</span><span class="comment">   * it seems better to crash-and-burn (choice 1), in the same way an attempt to resize()-higher a non-zero() blob would</span></div>
<div class="line"><a id="l00493" name="l00493"></a><span class="lineno">  493</span><span class="comment">   * crash and burn, forcing the user to explicitly execute what they want.  After all, 3 is done by simply calling</span></div>
<div class="line"><a id="l00494" name="l00494"></a><span class="lineno">  494</span><span class="comment">   * make_zero() first; and 2 is possible with a simple resize() call; and the blobs_sharing() check is both easy</span></div>
<div class="line"><a id="l00495" name="l00495"></a><span class="lineno">  495</span><span class="comment">   * and performant.</span></div>
<div class="line"><a id="l00496" name="l00496"></a><span class="lineno">  496</span><span class="comment">   *</span></div>
<div class="line"><a id="l00497" name="l00497"></a><span class="lineno">  497</span><span class="comment">   * @warning A post-condition is `start() == 0`; meaning `start()` at entry is ignored and reset to 0; the entire</span></div>
<div class="line"><a id="l00498" name="l00498"></a><span class="lineno">  498</span><span class="comment">   *          (co-)owned buffer -- if any -- is potentially used to store the copied values.  In particular, if one</span></div>
<div class="line"><a id="l00499" name="l00499"></a><span class="lineno">  499</span><span class="comment">   *          plans to work on a sub-blob of a shared pool (see class doc header), then using this assignment op is</span></div>
<div class="line"><a id="l00500" name="l00500"></a><span class="lineno">  500</span><span class="comment">   *          not advised.  Use emplace_copy() instead; or perform your own copy onto</span></div>
<div class="line"><a id="l00501" name="l00501"></a><span class="lineno">  501</span><span class="comment">   *          mutable_buffer().</span></div>
<div class="line"><a id="l00502" name="l00502"></a><span class="lineno">  502</span><span class="comment">   *</span></div>
<div class="line"><a id="l00503" name="l00503"></a><span class="lineno">  503</span><span class="comment">   * @param src</span></div>
<div class="line"><a id="l00504" name="l00504"></a><span class="lineno">  504</span><span class="comment">   *        Object whose range of bytes of length `src.size()` starting at `src.begin()` is copied into `*this`.</span></div>
<div class="line"><a id="l00505" name="l00505"></a><span class="lineno">  505</span><span class="comment">   *        Behavior is undefined if pre-condition is `!zero()`, and this memory area overlaps at any point with the</span></div>
<div class="line"><a id="l00506" name="l00506"></a><span class="lineno">  506</span><span class="comment">   *        memory area of same size in `*this` (unless that size is zero -- a degenerate case).</span></div>
<div class="line"><a id="l00507" name="l00507"></a><span class="lineno">  507</span><span class="comment">   *        (This can occur only via the use of `share*()` -- otherwise `Basic_blob`s always refer to separate areas.)</span></div>
<div class="line"><a id="l00508" name="l00508"></a><span class="lineno">  508</span><span class="comment">   *        Also behavior undefined if pre-condition is `!zero()`, and `*this` (co-)owned buffer is too short to</span></div>
<div class="line"><a id="l00509" name="l00509"></a><span class="lineno">  509</span><span class="comment">   *        accomodate all `src.size()` bytes (assertion may trip).</span></div>
<div class="line"><a id="l00510" name="l00510"></a><span class="lineno">  510</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00511" name="l00511"></a><span class="lineno">  511</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00512" name="l00512"></a><span class="lineno">  512</span><span class="comment">   * @return `*this`.</span></div>
<div class="line"><a id="l00513" name="l00513"></a><span class="lineno">  513</span><span class="comment">   */</span></div>
<div class="line"><a id="l00514" name="l00514"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aff44a959c238ea8aae3230c0b834d558">  514</a></span>  <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#aff44a959c238ea8aae3230c0b834d558">assign</a>(<span class="keyword">const</span> <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; src, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00515" name="l00515"></a><span class="lineno">  515</span><span class="comment"></span> </div>
<div class="line"><a id="l00516" name="l00516"></a><span class="lineno">  516</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00517" name="l00517"></a><span class="lineno">  517</span><span class="comment">   * Copy assignment operator (no logging): equivalent to `assign(src, nullptr)`.</span></div>
<div class="line"><a id="l00518" name="l00518"></a><span class="lineno">  518</span><span class="comment">   *</span></div>
<div class="line"><a id="l00519" name="l00519"></a><span class="lineno">  519</span><span class="comment">   * @param src</span></div>
<div class="line"><a id="l00520" name="l00520"></a><span class="lineno">  520</span><span class="comment">   *        See assign() (copy overload).</span></div>
<div class="line"><a id="l00521" name="l00521"></a><span class="lineno">  521</span><span class="comment">   * @return `*this`.</span></div>
<div class="line"><a id="l00522" name="l00522"></a><span class="lineno">  522</span><span class="comment">   */</span></div>
<div class="line"><a id="l00523" name="l00523"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a72eda661d71306c2fbd0422993922309">  523</a></span>  <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a72eda661d71306c2fbd0422993922309">operator=</a>(<span class="keyword">const</span> <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; src);</div>
<div class="line"><a id="l00524" name="l00524"></a><span class="lineno">  524</span><span class="comment"></span> </div>
<div class="line"><a id="l00525" name="l00525"></a><span class="lineno">  525</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00526" name="l00526"></a><span class="lineno">  526</span><span class="comment">   * Swaps the contents of this structure and `other`, or no-op if `this == &amp;other`.  Performance: at most this</span></div>
<div class="line"><a id="l00527" name="l00527"></a><span class="lineno">  527</span><span class="comment">   * involves swapping a few scalars which is constant-time.</span></div>
<div class="line"><a id="l00528" name="l00528"></a><span class="lineno">  528</span><span class="comment">   *</span></div>
<div class="line"><a id="l00529" name="l00529"></a><span class="lineno">  529</span><span class="comment">   * @param other</span></div>
<div class="line"><a id="l00530" name="l00530"></a><span class="lineno">  530</span><span class="comment">   *        The other structure.</span></div>
<div class="line"><a id="l00531" name="l00531"></a><span class="lineno">  531</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00532" name="l00532"></a><span class="lineno">  532</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00533" name="l00533"></a><span class="lineno">  533</span><span class="comment">   */</span></div>
<div class="line"><a id="l00534" name="l00534"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a3707ab8d2693a394c661b742d2626d4e">  534</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a3707ab8d2693a394c661b742d2626d4e">swap</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; other, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00535" name="l00535"></a><span class="lineno">  535</span><span class="comment"></span> </div>
<div class="line"><a id="l00536" name="l00536"></a><span class="lineno">  536</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00537" name="l00537"></a><span class="lineno">  537</span><span class="comment">   * Applicable to `!zero()` blobs, this returns an identical Basic_blob that shares (co-owns) `*this` allocated buffer</span></div>
<div class="line"><a id="l00538" name="l00538"></a><span class="lineno">  538</span><span class="comment">   * along with `*this` and any other `Basic_blob`s also sharing it.  Behavior is undefined (assertion may trip) if</span></div>
<div class="line"><a id="l00539" name="l00539"></a><span class="lineno">  539</span><span class="comment">   * `zero() == true`: it is nonsensical to co-own nothing; just use the default ctor then.</span></div>
<div class="line"><a id="l00540" name="l00540"></a><span class="lineno">  540</span><span class="comment">   *</span></div>
<div class="line"><a id="l00541" name="l00541"></a><span class="lineno">  541</span><span class="comment">   * The returned Basic_blob is identical in that not only does it share the same memory area (hence same capacity())</span></div>
<div class="line"><a id="l00542" name="l00542"></a><span class="lineno">  542</span><span class="comment">   * but has identical start(), size() (and hence begin() and end()).  If you&#39;d like to work on a different</span></div>
<div class="line"><a id="l00543" name="l00543"></a><span class="lineno">  543</span><span class="comment">   * part of the allocated buffer, please consider `share_after_split*()` instead; the pool-of-sub-`Basic_blob`s</span></div>
<div class="line"><a id="l00544" name="l00544"></a><span class="lineno">  544</span><span class="comment">   * paradigm suggested in the class doc header is probably best accomplished using those methods and not share().</span></div>
<div class="line"><a id="l00545" name="l00545"></a><span class="lineno">  545</span><span class="comment">   *</span></div>
<div class="line"><a id="l00546" name="l00546"></a><span class="lineno">  546</span><span class="comment">   * You can also adjust various sharing `Basic_blob`s via resize(), start_past_prefix_inc(), etc., directly -- after</span></div>
<div class="line"><a id="l00547" name="l00547"></a><span class="lineno">  547</span><span class="comment">   * share() returns.</span></div>
<div class="line"><a id="l00548" name="l00548"></a><span class="lineno">  548</span><span class="comment">   *</span></div>
<div class="line"><a id="l00549" name="l00549"></a><span class="lineno">  549</span><span class="comment">   * Formally: Before this returns, the internal ownership ref-count (shared among `*this` and the returned</span></div>
<div class="line"><a id="l00550" name="l00550"></a><span class="lineno">  550</span><span class="comment">   * Basic_blob) is incremented.</span></div>
<div class="line"><a id="l00551" name="l00551"></a><span class="lineno">  551</span><span class="comment">   *</span></div>
<div class="line"><a id="l00552" name="l00552"></a><span class="lineno">  552</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00553" name="l00553"></a><span class="lineno">  553</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00554" name="l00554"></a><span class="lineno">  554</span><span class="comment">   * @return An identical Basic_blob to `*this` that shares the underlying allocated buffer.  See above.</span></div>
<div class="line"><a id="l00555" name="l00555"></a><span class="lineno">  555</span><span class="comment">   */</span></div>
<div class="line"><a id="l00556" name="l00556"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a0044410b7d1f541978a309f02b2739d3">  556</a></span>  <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a0044410b7d1f541978a309f02b2739d3">share</a>(<a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>) <span class="keyword">const</span>;</div>
<div class="line"><a id="l00557" name="l00557"></a><span class="lineno">  557</span><span class="comment"></span> </div>
<div class="line"><a id="l00558" name="l00558"></a><span class="lineno">  558</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00559" name="l00559"></a><span class="lineno">  559</span><span class="comment">   * Applicable to `!zero()` blobs, this shifts `this-&gt;begin()` by `size` to the right without changing</span></div>
<div class="line"><a id="l00560" name="l00560"></a><span class="lineno">  560</span><span class="comment">   * end(); and returns a Basic_blob containing the shifted-past values that shares (co-owns) `*this` allocated buffer</span></div>
<div class="line"><a id="l00561" name="l00561"></a><span class="lineno">  561</span><span class="comment">   * along with `*this` and any other `Basic_blob`s also sharing it.</span></div>
<div class="line"><a id="l00562" name="l00562"></a><span class="lineno">  562</span><span class="comment">   *</span></div>
<div class="line"><a id="l00563" name="l00563"></a><span class="lineno">  563</span><span class="comment">   * More formally, this is identical to simply `auto b = share(); b.resize(size); start_past_prefix_inc(size);`.</span></div>
<div class="line"><a id="l00564" name="l00564"></a><span class="lineno">  564</span><span class="comment">   *</span></div>
<div class="line"><a id="l00565" name="l00565"></a><span class="lineno">  565</span><span class="comment">   * This is useful when working in the pool-of-sub-`Basic_blob`s paradigm.  This and other `share_after_split*()`</span></div>
<div class="line"><a id="l00566" name="l00566"></a><span class="lineno">  566</span><span class="comment">   * methods are usually better to use rather than share() directly (for that paradigm).</span></div>
<div class="line"><a id="l00567" name="l00567"></a><span class="lineno">  567</span><span class="comment">   *</span></div>
<div class="line"><a id="l00568" name="l00568"></a><span class="lineno">  568</span><span class="comment">   * Behavior is undefined (assertion may trip) if `zero() == true`.</span></div>
<div class="line"><a id="l00569" name="l00569"></a><span class="lineno">  569</span><span class="comment">   *</span></div>
<div class="line"><a id="l00570" name="l00570"></a><span class="lineno">  570</span><span class="comment">   * Corner case: If `size &gt; size()`, then it is taken to equal size().</span></div>
<div class="line"><a id="l00571" name="l00571"></a><span class="lineno">  571</span><span class="comment">   *</span></div>
<div class="line"><a id="l00572" name="l00572"></a><span class="lineno">  572</span><span class="comment">   * Degenerate case: If `size` (or size(), whichever is smaller) is 0, then this method is identical to</span></div>
<div class="line"><a id="l00573" name="l00573"></a><span class="lineno">  573</span><span class="comment">   * share().  Probably you don&#39;t mean to call share_after_split_left() in that case, but it&#39;s your decision.</span></div>
<div class="line"><a id="l00574" name="l00574"></a><span class="lineno">  574</span><span class="comment">   *</span></div>
<div class="line"><a id="l00575" name="l00575"></a><span class="lineno">  575</span><span class="comment">   * Degenerate case: If `size == size()` (and not 0), then `this-&gt;empty()` becomes `true` -- though</span></div>
<div class="line"><a id="l00576" name="l00576"></a><span class="lineno">  576</span><span class="comment">   * `*this` continues to share the underlying buffer despite [begin(), end()) becoming empty.  Typically this would</span></div>
<div class="line"><a id="l00577" name="l00577"></a><span class="lineno">  577</span><span class="comment">   * only be done as, perhaps, the last iteration of some progressively-splitting loop; but it&#39;s your decision.</span></div>
<div class="line"><a id="l00578" name="l00578"></a><span class="lineno">  578</span><span class="comment">   *</span></div>
<div class="line"><a id="l00579" name="l00579"></a><span class="lineno">  579</span><span class="comment">   * Formally: Before this returns, the internal ownership ref-count (shared among `*this` and the returned</span></div>
<div class="line"><a id="l00580" name="l00580"></a><span class="lineno">  580</span><span class="comment">   * Basic_blob) is incremented.</span></div>
<div class="line"><a id="l00581" name="l00581"></a><span class="lineno">  581</span><span class="comment">   *</span></div>
<div class="line"><a id="l00582" name="l00582"></a><span class="lineno">  582</span><span class="comment">   * @param size</span></div>
<div class="line"><a id="l00583" name="l00583"></a><span class="lineno">  583</span><span class="comment">   *        Desired size() of the returned Basic_blob; and the number of elements by which `this-&gt;begin()` is</span></div>
<div class="line"><a id="l00584" name="l00584"></a><span class="lineno">  584</span><span class="comment">   *        shifted right (hence start() is incremented).  Any value exceeding size() is taken to equal it.</span></div>
<div class="line"><a id="l00585" name="l00585"></a><span class="lineno">  585</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00586" name="l00586"></a><span class="lineno">  586</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00587" name="l00587"></a><span class="lineno">  587</span><span class="comment">   * @return The split-off-on-the-left Basic_blob that shares the underlying allocated buffer with `*this`.  See above.</span></div>
<div class="line"><a id="l00588" name="l00588"></a><span class="lineno">  588</span><span class="comment">   */</span></div>
<div class="line"><a id="l00589" name="l00589"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a6c0635640d16084eb975a9fb97f96aab">  589</a></span>  <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a6c0635640d16084eb975a9fb97f96aab">share_after_split_left</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">size</a>, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00590" name="l00590"></a><span class="lineno">  590</span><span class="comment"></span> </div>
<div class="line"><a id="l00591" name="l00591"></a><span class="lineno">  591</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00592" name="l00592"></a><span class="lineno">  592</span><span class="comment">   * Identical to share_after_split_left(), except `this-&gt;end()` shifts by `size` to the left (instead of</span></div>
<div class="line"><a id="l00593" name="l00593"></a><span class="lineno">  593</span><span class="comment">   * `this-&gt;begin() to the right), and the split-off Basic_blob contains the *right-most* `size` elements</span></div>
<div class="line"><a id="l00594" name="l00594"></a><span class="lineno">  594</span><span class="comment">   * (instead of the left-most).</span></div>
<div class="line"><a id="l00595" name="l00595"></a><span class="lineno">  595</span><span class="comment">   *</span></div>
<div class="line"><a id="l00596" name="l00596"></a><span class="lineno">  596</span><span class="comment">   * More formally, this is identical to simply</span></div>
<div class="line"><a id="l00597" name="l00597"></a><span class="lineno">  597</span><span class="comment">   * `auto lt_size = size() - size; auto b = share(); resize(lt_size); b.start_past_prefix_inc(lt_size);`.</span></div>
<div class="line"><a id="l00598" name="l00598"></a><span class="lineno">  598</span><span class="comment">   * Cf. share_after_split_left() formal definition and note the symmetry.</span></div>
<div class="line"><a id="l00599" name="l00599"></a><span class="lineno">  599</span><span class="comment">   *</span></div>
<div class="line"><a id="l00600" name="l00600"></a><span class="lineno">  600</span><span class="comment">   * All other characteristics are as written for share_after_split_left().</span></div>
<div class="line"><a id="l00601" name="l00601"></a><span class="lineno">  601</span><span class="comment">   *</span></div>
<div class="line"><a id="l00602" name="l00602"></a><span class="lineno">  602</span><span class="comment">   * @param size</span></div>
<div class="line"><a id="l00603" name="l00603"></a><span class="lineno">  603</span><span class="comment">   *        Desired size() of the returned Basic_blob; and the number of elements by which `this-&gt;end()` is</span></div>
<div class="line"><a id="l00604" name="l00604"></a><span class="lineno">  604</span><span class="comment">   *        shifted left (hence size() is decremented).  Any value exceeding size() is taken to equal it.</span></div>
<div class="line"><a id="l00605" name="l00605"></a><span class="lineno">  605</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00606" name="l00606"></a><span class="lineno">  606</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00607" name="l00607"></a><span class="lineno">  607</span><span class="comment">   * @return The split-off-on-the-right Basic_blob that shares the underlying allocated buffer with `*this`.  See above.</span></div>
<div class="line"><a id="l00608" name="l00608"></a><span class="lineno">  608</span><span class="comment">   */</span></div>
<div class="line"><a id="l00609" name="l00609"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aedd12dc6003934e156e3dc100e7c193e">  609</a></span>  <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#aedd12dc6003934e156e3dc100e7c193e">share_after_split_right</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">size</a>, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00610" name="l00610"></a><span class="lineno">  610</span><span class="comment"></span> </div>
<div class="line"><a id="l00611" name="l00611"></a><span class="lineno">  611</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00612" name="l00612"></a><span class="lineno">  612</span><span class="comment">   * Identical to successively performing `share_after_split_left(size)` until `this-&gt;empty() == true`;</span></div>
<div class="line"><a id="l00613" name="l00613"></a><span class="lineno">  613</span><span class="comment">   * the resultings `Basic_blob`s are emitted via `emit_blob_func()` callback in the order they&#39;re split off from</span></div>
<div class="line"><a id="l00614" name="l00614"></a><span class="lineno">  614</span><span class="comment">   * the left.  In other words this partitions a non-zero() `Basic_blob` -- perhaps typically used as a pool --</span></div>
<div class="line"><a id="l00615" name="l00615"></a><span class="lineno">  615</span><span class="comment">   * into equally-sized (except possibly the last one) adjacent sub-`Basic_blob`s.</span></div>
<div class="line"><a id="l00616" name="l00616"></a><span class="lineno">  616</span><span class="comment">   *</span></div>
<div class="line"><a id="l00617" name="l00617"></a><span class="lineno">  617</span><span class="comment">   * A post-condition is that `empty() == true` (`size() == 0`).  In addition, if `headless_pool == true`,</span></div>
<div class="line"><a id="l00618" name="l00618"></a><span class="lineno">  618</span><span class="comment">   * then `zero() == true` is also a post-condition; i.e., the pool is &quot;headless&quot;: it disappears once all the</span></div>
<div class="line"><a id="l00619" name="l00619"></a><span class="lineno">  619</span><span class="comment">   * resulting sub-`Basic_blob`s drop their ownership (as well as any other co-owning `Basic_blob`s).</span></div>
<div class="line"><a id="l00620" name="l00620"></a><span class="lineno">  620</span><span class="comment">   * Otherwise, `*this` will continue to share the pool despite size() becoming 0.  (Of course, even then, one is</span></div>
<div class="line"><a id="l00621" name="l00621"></a><span class="lineno">  621</span><span class="comment">   * free to make_zero() or destroy `*this` -- the former, before returning, is all that `headless_pool == true`</span></div>
<div class="line"><a id="l00622" name="l00622"></a><span class="lineno">  622</span><span class="comment">   * really adds.)</span></div>
<div class="line"><a id="l00623" name="l00623"></a><span class="lineno">  623</span><span class="comment">   *</span></div>
<div class="line"><a id="l00624" name="l00624"></a><span class="lineno">  624</span><span class="comment">   * Behavior is undefined (assertion may trip) if `empty() == true` (including if `zero() == true`, but even if not)</span></div>
<div class="line"><a id="l00625" name="l00625"></a><span class="lineno">  625</span><span class="comment">   * or if `size == 0`.</span></div>
<div class="line"><a id="l00626" name="l00626"></a><span class="lineno">  626</span><span class="comment">   *</span></div>
<div class="line"><a id="l00627" name="l00627"></a><span class="lineno">  627</span><span class="comment">   * @see share_after_split_equally_emit_seq() for a convenience wrapper to emit to, say, `vector&lt;Basic_blob&gt;`.</span></div>
<div class="line"><a id="l00628" name="l00628"></a><span class="lineno">  628</span><span class="comment">   * @see share_after_split_equally_emit_ptr_seq() for a convenience wrapper to emit to, say,</span></div>
<div class="line"><a id="l00629" name="l00629"></a><span class="lineno">  629</span><span class="comment">   *      `vector&lt;unique_ptr&lt;Basic_blob&gt;&gt;`.</span></div>
<div class="line"><a id="l00630" name="l00630"></a><span class="lineno">  630</span><span class="comment">   *</span></div>
<div class="line"><a id="l00631" name="l00631"></a><span class="lineno">  631</span><span class="comment">   * @tparam Emit_blob_func</span></div>
<div class="line"><a id="l00632" name="l00632"></a><span class="lineno">  632</span><span class="comment">   *         A callback compatible with signature `void F(Basic_blob&amp;&amp; blob_moved)`.</span></div>
<div class="line"><a id="l00633" name="l00633"></a><span class="lineno">  633</span><span class="comment">   * @param size</span></div>
<div class="line"><a id="l00634" name="l00634"></a><span class="lineno">  634</span><span class="comment">   *        Desired size() of each successive out-Basic_blob, except the last one.  Behavior undefined (assertion may</span></div>
<div class="line"><a id="l00635" name="l00635"></a><span class="lineno">  635</span><span class="comment">   *        trip) if not positive.</span></div>
<div class="line"><a id="l00636" name="l00636"></a><span class="lineno">  636</span><span class="comment">   * @param headless_pool</span></div>
<div class="line"><a id="l00637" name="l00637"></a><span class="lineno">  637</span><span class="comment">   *        Whether to perform `this-&gt;make_zero()` just before returning.  See above.</span></div>
<div class="line"><a id="l00638" name="l00638"></a><span class="lineno">  638</span><span class="comment">   * @param emit_blob_func</span></div>
<div class="line"><a id="l00639" name="l00639"></a><span class="lineno">  639</span><span class="comment">   *        `F` such that `F(std::move(blob))` shall be called with each successive sub-Basic_blob.</span></div>
<div class="line"><a id="l00640" name="l00640"></a><span class="lineno">  640</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00641" name="l00641"></a><span class="lineno">  641</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00642" name="l00642"></a><span class="lineno">  642</span><span class="comment">   */</span></div>
<div class="line"><a id="l00643" name="l00643"></a><span class="lineno">  643</span>  <span class="keyword">template</span>&lt;<span class="keyword">typename</span> Emit_blob_func&gt;</div>
<div class="line"><a id="l00644" name="l00644"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a2e4aa425939071a4fb313d3237987226">  644</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a2e4aa425939071a4fb313d3237987226">share_after_split_equally</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">size</a>, <span class="keywordtype">bool</span> headless_pool, Emit_blob_func&amp;&amp; emit_blob_func,</div>
<div class="line"><a id="l00645" name="l00645"></a><span class="lineno">  645</span>                                 <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00646" name="l00646"></a><span class="lineno">  646</span><span class="comment"></span> </div>
<div class="line"><a id="l00647" name="l00647"></a><span class="lineno">  647</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00648" name="l00648"></a><span class="lineno">  648</span><span class="comment">   * share_after_split_equally() wrapper that places `Basic_blob`s into the given container via</span></div>
<div class="line"><a id="l00649" name="l00649"></a><span class="lineno">  649</span><span class="comment">   * `push_back()`.</span></div>
<div class="line"><a id="l00650" name="l00650"></a><span class="lineno">  650</span><span class="comment">   *</span></div>
<div class="line"><a id="l00651" name="l00651"></a><span class="lineno">  651</span><span class="comment">   * @tparam Blob_container</span></div>
<div class="line"><a id="l00652" name="l00652"></a><span class="lineno">  652</span><span class="comment">   *         Something with method compatible with `push_back(Basic_blob&amp;&amp; blob_moved)`.</span></div>
<div class="line"><a id="l00653" name="l00653"></a><span class="lineno">  653</span><span class="comment">   * @param size</span></div>
<div class="line"><a id="l00654" name="l00654"></a><span class="lineno">  654</span><span class="comment">   *        See share_after_split_equally().</span></div>
<div class="line"><a id="l00655" name="l00655"></a><span class="lineno">  655</span><span class="comment">   * @param headless_pool</span></div>
<div class="line"><a id="l00656" name="l00656"></a><span class="lineno">  656</span><span class="comment">   *        See share_after_split_equally().</span></div>
<div class="line"><a id="l00657" name="l00657"></a><span class="lineno">  657</span><span class="comment">   * @param out_blobs</span></div>
<div class="line"><a id="l00658" name="l00658"></a><span class="lineno">  658</span><span class="comment">   *        `out_blobs-&gt;push_back()` shall be executed 1+ times.</span></div>
<div class="line"><a id="l00659" name="l00659"></a><span class="lineno">  659</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00660" name="l00660"></a><span class="lineno">  660</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00661" name="l00661"></a><span class="lineno">  661</span><span class="comment">   */</span></div>
<div class="line"><a id="l00662" name="l00662"></a><span class="lineno">  662</span>  <span class="keyword">template</span>&lt;<span class="keyword">typename</span> Blob_container&gt;</div>
<div class="line"><a id="l00663" name="l00663"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aa025a04ef0a19aa2065cab61a2b3a92c">  663</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#aa025a04ef0a19aa2065cab61a2b3a92c">share_after_split_equally_emit_seq</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">size</a>, <span class="keywordtype">bool</span> headless_pool, Blob_container* out_blobs,</div>
<div class="line"><a id="l00664" name="l00664"></a><span class="lineno">  664</span>                                          <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00665" name="l00665"></a><span class="lineno">  665</span><span class="comment"></span> </div>
<div class="line"><a id="l00666" name="l00666"></a><span class="lineno">  666</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00667" name="l00667"></a><span class="lineno">  667</span><span class="comment">   * share_after_split_equally() wrapper that places `Ptr&lt;Basic_blob&gt;`s into the given container via</span></div>
<div class="line"><a id="l00668" name="l00668"></a><span class="lineno">  668</span><span class="comment">   * `push_back()`, where the type `Ptr&lt;&gt;` is determined via `Blob_ptr_container::value_type`.</span></div>
<div class="line"><a id="l00669" name="l00669"></a><span class="lineno">  669</span><span class="comment">   *</span></div>
<div class="line"><a id="l00670" name="l00670"></a><span class="lineno">  670</span><span class="comment">   * @tparam Blob_ptr_container</span></div>
<div class="line"><a id="l00671" name="l00671"></a><span class="lineno">  671</span><span class="comment">   *         Something with method compatible with `push_back(Ptr&amp;&amp; blob_ptr_moved)`,</span></div>
<div class="line"><a id="l00672" name="l00672"></a><span class="lineno">  672</span><span class="comment">   *         where `Ptr` is `Blob_ptr_container::value_type`, and `Ptr(new Basic_blob)` can be created.</span></div>
<div class="line"><a id="l00673" name="l00673"></a><span class="lineno">  673</span><span class="comment">   *         `Ptr` is to be a smart pointer type such as `unique_ptr&lt;Basic_blob&gt;` or `shared_ptr&lt;Basic_blob&gt;`.</span></div>
<div class="line"><a id="l00674" name="l00674"></a><span class="lineno">  674</span><span class="comment">   * @param size</span></div>
<div class="line"><a id="l00675" name="l00675"></a><span class="lineno">  675</span><span class="comment">   *        See share_after_split_equally().</span></div>
<div class="line"><a id="l00676" name="l00676"></a><span class="lineno">  676</span><span class="comment">   * @param headless_pool</span></div>
<div class="line"><a id="l00677" name="l00677"></a><span class="lineno">  677</span><span class="comment">   *        See share_after_split_equally().</span></div>
<div class="line"><a id="l00678" name="l00678"></a><span class="lineno">  678</span><span class="comment">   * @param out_blobs</span></div>
<div class="line"><a id="l00679" name="l00679"></a><span class="lineno">  679</span><span class="comment">   *        `out_blobs-&gt;push_back()` shall be executed 1+ times.</span></div>
<div class="line"><a id="l00680" name="l00680"></a><span class="lineno">  680</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00681" name="l00681"></a><span class="lineno">  681</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00682" name="l00682"></a><span class="lineno">  682</span><span class="comment">   */</span></div>
<div class="line"><a id="l00683" name="l00683"></a><span class="lineno">  683</span>  <span class="keyword">template</span>&lt;<span class="keyword">typename</span> Blob_ptr_container&gt;</div>
<div class="line"><a id="l00684" name="l00684"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#acf07a3d48fd3b216ed2a08a088b7ba6a">  684</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#acf07a3d48fd3b216ed2a08a088b7ba6a">share_after_split_equally_emit_ptr_seq</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">size</a>, <span class="keywordtype">bool</span> headless_pool, Blob_ptr_container* out_blobs,</div>
<div class="line"><a id="l00685" name="l00685"></a><span class="lineno">  685</span>                                              <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00686" name="l00686"></a><span class="lineno">  686</span><span class="comment"></span> </div>
<div class="line"><a id="l00687" name="l00687"></a><span class="lineno">  687</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00688" name="l00688"></a><span class="lineno">  688</span><span class="comment">   * Replaces logical contents with a copy of the given non-overlapping area anywhere in memory.  More formally:</span></div>
<div class="line"><a id="l00689" name="l00689"></a><span class="lineno">  689</span><span class="comment">   * This is exactly equivalent to copy-assignment (`*this = b`), where `const Basic_blob b` owns exactly</span></div>
<div class="line"><a id="l00690" name="l00690"></a><span class="lineno">  690</span><span class="comment">   * the memory area given by `src`.  However, note the newly relevant restriction documented for `src` parameter below</span></div>
<div class="line"><a id="l00691" name="l00691"></a><span class="lineno">  691</span><span class="comment">   * (no overlap allowed).</span></div>
<div class="line"><a id="l00692" name="l00692"></a><span class="lineno">  692</span><span class="comment">   *</span></div>
<div class="line"><a id="l00693" name="l00693"></a><span class="lineno">  693</span><span class="comment">   * All characteristics are as written for the copy assignment operator, including &quot;Formally&quot; and the warning.</span></div>
<div class="line"><a id="l00694" name="l00694"></a><span class="lineno">  694</span><span class="comment">   *</span></div>
<div class="line"><a id="l00695" name="l00695"></a><span class="lineno">  695</span><span class="comment">   * @param src</span></div>
<div class="line"><a id="l00696" name="l00696"></a><span class="lineno">  696</span><span class="comment">   *        Source memory area.  Behavior is undefined if pre-condition is `!zero()`, and this memory area overlaps</span></div>
<div class="line"><a id="l00697" name="l00697"></a><span class="lineno">  697</span><span class="comment">   *        at any point with the memory area of same size at `begin()`.  Otherwise it can be anywhere at all.</span></div>
<div class="line"><a id="l00698" name="l00698"></a><span class="lineno">  698</span><span class="comment">   *        Also behavior undefined if pre-condition is `!zero()`, and `*this` (co-)owned buffer is too short to</span></div>
<div class="line"><a id="l00699" name="l00699"></a><span class="lineno">  699</span><span class="comment">   *        accomodate all `src.size()` bytes (assertion may trip).</span></div>
<div class="line"><a id="l00700" name="l00700"></a><span class="lineno">  700</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00701" name="l00701"></a><span class="lineno">  701</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00702" name="l00702"></a><span class="lineno">  702</span><span class="comment">   * @return Number of elements copied, namely `src.size()`, or simply size().</span></div>
<div class="line"><a id="l00703" name="l00703"></a><span class="lineno">  703</span><span class="comment">   */</span></div>
<div class="line"><a id="l00704" name="l00704"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a4939ea2f0c76ec448cdc12275ce17f33">  704</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a4939ea2f0c76ec448cdc12275ce17f33">assign_copy</a>(<span class="keyword">const</span> boost::asio::const_buffer&amp; src, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00705" name="l00705"></a><span class="lineno">  705</span><span class="comment"></span> </div>
<div class="line"><a id="l00706" name="l00706"></a><span class="lineno">  706</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00707" name="l00707"></a><span class="lineno">  707</span><span class="comment">   * Copies `src` buffer directly onto equally sized area within `*this` at location `dest`; `*this` must have</span></div>
<div class="line"><a id="l00708" name="l00708"></a><span class="lineno">  708</span><span class="comment">   * sufficient size() to accomodate all of the data copied.  Performance: The only operation performed is a copy from</span></div>
<div class="line"><a id="l00709" name="l00709"></a><span class="lineno">  709</span><span class="comment">   * `src` to `dest` using the fastest reasonably available technique.</span></div>
<div class="line"><a id="l00710" name="l00710"></a><span class="lineno">  710</span><span class="comment">   *</span></div>
<div class="line"><a id="l00711" name="l00711"></a><span class="lineno">  711</span><span class="comment">   * None of the following changes: zero(), empty(), size(), capacity(), begin(), end(); nor the location (or size) of</span></div>
<div class="line"><a id="l00712" name="l00712"></a><span class="lineno">  712</span><span class="comment">   * internally stored buffer.</span></div>
<div class="line"><a id="l00713" name="l00713"></a><span class="lineno">  713</span><span class="comment">   *</span></div>
<div class="line"><a id="l00714" name="l00714"></a><span class="lineno">  714</span><span class="comment">   * @param dest</span></div>
<div class="line"><a id="l00715" name="l00715"></a><span class="lineno">  715</span><span class="comment">   *        Destination location within this blob.  This must be in `[begin(), end()]`; and,</span></div>
<div class="line"><a id="l00716" name="l00716"></a><span class="lineno">  716</span><span class="comment">   *        unless `src.size() == 0`, must not equal end() either.</span></div>
<div class="line"><a id="l00717" name="l00717"></a><span class="lineno">  717</span><span class="comment">   * @param src</span></div>
<div class="line"><a id="l00718" name="l00718"></a><span class="lineno">  718</span><span class="comment">   *        Source memory area.  Behavior is undefined if this memory area overlaps</span></div>
<div class="line"><a id="l00719" name="l00719"></a><span class="lineno">  719</span><span class="comment">   *        at any point with the memory area of same size at `dest` (unless that size is zero -- a degenerate</span></div>
<div class="line"><a id="l00720" name="l00720"></a><span class="lineno">  720</span><span class="comment">   *        case).  Otherwise it can be anywhere at all, even partially or fully within `*this`.</span></div>
<div class="line"><a id="l00721" name="l00721"></a><span class="lineno">  721</span><span class="comment">   *        Also behavior undefined if `*this` blob is too short to accomodate all `src.size()` bytes</span></div>
<div class="line"><a id="l00722" name="l00722"></a><span class="lineno">  722</span><span class="comment">   *        (assertion may trip).</span></div>
<div class="line"><a id="l00723" name="l00723"></a><span class="lineno">  723</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00724" name="l00724"></a><span class="lineno">  724</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00725" name="l00725"></a><span class="lineno">  725</span><span class="comment">   * @return Location in this blob just past the last element copied; `dest` if none copied; in particular end() is a</span></div>
<div class="line"><a id="l00726" name="l00726"></a><span class="lineno">  726</span><span class="comment">   *         possible value.</span></div>
<div class="line"><a id="l00727" name="l00727"></a><span class="lineno">  727</span><span class="comment">   */</span></div>
<div class="line"><a id="l00728" name="l00728"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a9113cfc8160e93a0e0fa45de8058b858">  728</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9113cfc8160e93a0e0fa45de8058b858">emplace_copy</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> dest, <span class="keyword">const</span> boost::asio::const_buffer&amp; src, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00729" name="l00729"></a><span class="lineno">  729</span><span class="comment"></span> </div>
<div class="line"><a id="l00730" name="l00730"></a><span class="lineno">  730</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00731" name="l00731"></a><span class="lineno">  731</span><span class="comment">   * The opposite of emplace_copy() in every way, copying a sub-blob onto a target memory area.  Note that the size</span></div>
<div class="line"><a id="l00732" name="l00732"></a><span class="lineno">  732</span><span class="comment">   * of that target buffer (`dest.size()`) determines how much of `*this` is copied.</span></div>
<div class="line"><a id="l00733" name="l00733"></a><span class="lineno">  733</span><span class="comment">   *</span></div>
<div class="line"><a id="l00734" name="l00734"></a><span class="lineno">  734</span><span class="comment">   * @param src</span></div>
<div class="line"><a id="l00735" name="l00735"></a><span class="lineno">  735</span><span class="comment">   *        Source location within this blob.  This must be in `[begin(), end()]`; and,</span></div>
<div class="line"><a id="l00736" name="l00736"></a><span class="lineno">  736</span><span class="comment">   *        unless `dest.size() == 0`, must not equal end() either.</span></div>
<div class="line"><a id="l00737" name="l00737"></a><span class="lineno">  737</span><span class="comment">   * @param dest</span></div>
<div class="line"><a id="l00738" name="l00738"></a><span class="lineno">  738</span><span class="comment">   *        Destination memory area.  Behavior is undefined if this memory area overlaps</span></div>
<div class="line"><a id="l00739" name="l00739"></a><span class="lineno">  739</span><span class="comment">   *        at any point with the memory area of same size at `src` (unless that size is zero -- a degenerate</span></div>
<div class="line"><a id="l00740" name="l00740"></a><span class="lineno">  740</span><span class="comment">   *        case).  Otherwise it can be anywhere at all, even partially or fully within `*this`.</span></div>
<div class="line"><a id="l00741" name="l00741"></a><span class="lineno">  741</span><span class="comment">   *        Also behavior undefined if `src + dest.size()` is past end of `*this` blob (assertion may trip).</span></div>
<div class="line"><a id="l00742" name="l00742"></a><span class="lineno">  742</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00743" name="l00743"></a><span class="lineno">  743</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00744" name="l00744"></a><span class="lineno">  744</span><span class="comment">   * @return Location in this blob just past the last element copied; `src` if none copied; end() is a possible value.</span></div>
<div class="line"><a id="l00745" name="l00745"></a><span class="lineno">  745</span><span class="comment">   */</span></div>
<div class="line"><a id="l00746" name="l00746"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aa2484d717fde243f6118ac4b0312df87">  746</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#aa2484d717fde243f6118ac4b0312df87">sub_copy</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> src, <span class="keyword">const</span> boost::asio::mutable_buffer&amp; dest,</div>
<div class="line"><a id="l00747" name="l00747"></a><span class="lineno">  747</span>                          <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>) <span class="keyword">const</span>;</div>
<div class="line"><a id="l00748" name="l00748"></a><span class="lineno">  748</span><span class="comment"></span> </div>
<div class="line"><a id="l00749" name="l00749"></a><span class="lineno">  749</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00750" name="l00750"></a><span class="lineno">  750</span><span class="comment">   * Returns number of elements stored, namely `end() - begin()`.  If zero(), this is 0; but if this is 0, then</span></div>
<div class="line"><a id="l00751" name="l00751"></a><span class="lineno">  751</span><span class="comment">   * zero() may or may not be `true`.</span></div>
<div class="line"><a id="l00752" name="l00752"></a><span class="lineno">  752</span><span class="comment">   *</span></div>
<div class="line"><a id="l00753" name="l00753"></a><span class="lineno">  753</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l00754" name="l00754"></a><span class="lineno">  754</span><span class="comment">   */</span></div>
<div class="line"><a id="l00755" name="l00755"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">  755</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">size</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l00756" name="l00756"></a><span class="lineno">  756</span><span class="comment"></span> </div>
<div class="line"><a id="l00757" name="l00757"></a><span class="lineno">  757</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00758" name="l00758"></a><span class="lineno">  758</span><span class="comment">   * Returns the offset between `begin()` and the start of the internally allocated buffer.  If zero(), this is 0; but</span></div>
<div class="line"><a id="l00759" name="l00759"></a><span class="lineno">  759</span><span class="comment">   * if this is 0, then zero() may or may not be `true`.</span></div>
<div class="line"><a id="l00760" name="l00760"></a><span class="lineno">  760</span><span class="comment">   *</span></div>
<div class="line"><a id="l00761" name="l00761"></a><span class="lineno">  761</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l00762" name="l00762"></a><span class="lineno">  762</span><span class="comment">   */</span></div>
<div class="line"><a id="l00763" name="l00763"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a64ea173065830ef1a744458a7d05b833">  763</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a64ea173065830ef1a744458a7d05b833">start</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l00764" name="l00764"></a><span class="lineno">  764</span><span class="comment"></span> </div>
<div class="line"><a id="l00765" name="l00765"></a><span class="lineno">  765</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00766" name="l00766"></a><span class="lineno">  766</span><span class="comment">   * Returns `size() == 0`.  If zero(), this is `true`; but if this is `true`, then</span></div>
<div class="line"><a id="l00767" name="l00767"></a><span class="lineno">  767</span><span class="comment">   * zero() may or may not be `true`.</span></div>
<div class="line"><a id="l00768" name="l00768"></a><span class="lineno">  768</span><span class="comment">   *</span></div>
<div class="line"><a id="l00769" name="l00769"></a><span class="lineno">  769</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l00770" name="l00770"></a><span class="lineno">  770</span><span class="comment">   */</span></div>
<div class="line"><a id="l00771" name="l00771"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a797741a0a5c95b13b36f356ae8d397e8">  771</a></span>  <span class="keywordtype">bool</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a797741a0a5c95b13b36f356ae8d397e8">empty</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l00772" name="l00772"></a><span class="lineno">  772</span><span class="comment"></span> </div>
<div class="line"><a id="l00773" name="l00773"></a><span class="lineno">  773</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00774" name="l00774"></a><span class="lineno">  774</span><span class="comment">   * Returns the number of elements in the internally allocated buffer, which is 1 or more; or 0 if no buffer</span></div>
<div class="line"><a id="l00775" name="l00775"></a><span class="lineno">  775</span><span class="comment">   * is internally allocated.  Some formal invariants: `(capacity() == 0) == zero()`; `start() + size() &lt;= capacity()`.</span></div>
<div class="line"><a id="l00776" name="l00776"></a><span class="lineno">  776</span><span class="comment">   *</span></div>
<div class="line"><a id="l00777" name="l00777"></a><span class="lineno">  777</span><span class="comment">   * See important notes on capacity() policy in the class doc header.</span></div>
<div class="line"><a id="l00778" name="l00778"></a><span class="lineno">  778</span><span class="comment">   *</span></div>
<div class="line"><a id="l00779" name="l00779"></a><span class="lineno">  779</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l00780" name="l00780"></a><span class="lineno">  780</span><span class="comment">   */</span></div>
<div class="line"><a id="l00781" name="l00781"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a719e5c04e4bdc65c31976fc385fd7f24">  781</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a719e5c04e4bdc65c31976fc385fd7f24">capacity</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l00782" name="l00782"></a><span class="lineno">  782</span><span class="comment"></span> </div>
<div class="line"><a id="l00783" name="l00783"></a><span class="lineno">  783</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00784" name="l00784"></a><span class="lineno">  784</span><span class="comment">   * Returns `false` if a buffer is allocated and owned; `true` otherwise.  See important notes on how this relates</span></div>
<div class="line"><a id="l00785" name="l00785"></a><span class="lineno">  785</span><span class="comment">   * to empty() and capacity() in those methods&#39; doc headers.  See also other important notes in class doc header.</span></div>
<div class="line"><a id="l00786" name="l00786"></a><span class="lineno">  786</span><span class="comment">   *</span></div>
<div class="line"><a id="l00787" name="l00787"></a><span class="lineno">  787</span><span class="comment">   * Note that zero() is `true` for any default-constructed Basic_blob.</span></div>
<div class="line"><a id="l00788" name="l00788"></a><span class="lineno">  788</span><span class="comment">   *</span></div>
<div class="line"><a id="l00789" name="l00789"></a><span class="lineno">  789</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l00790" name="l00790"></a><span class="lineno">  790</span><span class="comment">   */</span></div>
<div class="line"><a id="l00791" name="l00791"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a1a64646d656ec125fa8973ccf843c1be">  791</a></span>  <span class="keywordtype">bool</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a1a64646d656ec125fa8973ccf843c1be">zero</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l00792" name="l00792"></a><span class="lineno">  792</span><span class="comment"></span> </div>
<div class="line"><a id="l00793" name="l00793"></a><span class="lineno">  793</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00794" name="l00794"></a><span class="lineno">  794</span><span class="comment">   * Ensures that an internal buffer of at least `capacity` elements is allocated and owned; disallows growing an</span></div>
<div class="line"><a id="l00795" name="l00795"></a><span class="lineno">  795</span><span class="comment">   * existing buffer; never shrinks an existing buffer; if a buffer is allocated, it is no larger than `capacity`.</span></div>
<div class="line"><a id="l00796" name="l00796"></a><span class="lineno">  796</span><span class="comment">   *</span></div>
<div class="line"><a id="l00797" name="l00797"></a><span class="lineno">  797</span><span class="comment">   * reserve() may be called directly but should be formally understood to be called by resize(), assign_copy(),</span></div>
<div class="line"><a id="l00798" name="l00798"></a><span class="lineno">  798</span><span class="comment">   * copy assignment operator, copy constructor.  In all cases, the value passed to reserve() is exactly the size</span></div>
<div class="line"><a id="l00799" name="l00799"></a><span class="lineno">  799</span><span class="comment">   * needed to perform the particular task -- no more (and no less).  As such, reserve() policy is key to knowing</span></div>
<div class="line"><a id="l00800" name="l00800"></a><span class="lineno">  800</span><span class="comment">   * how the class behaves elsewhere.  See class doc header for discussion in larger context.</span></div>
<div class="line"><a id="l00801" name="l00801"></a><span class="lineno">  801</span><span class="comment">   *</span></div>
<div class="line"><a id="l00802" name="l00802"></a><span class="lineno">  802</span><span class="comment">   * Performance/behavior: If zero() is true pre-call, `capacity` sized buffer is allocated.  Otherwise,</span></div>
<div class="line"><a id="l00803" name="l00803"></a><span class="lineno">  803</span><span class="comment">   * no-op if `capacity &lt;= capacity()` pre-call.  Behavior is undefined if `capacity &gt; capacity()` pre-call</span></div>
<div class="line"><a id="l00804" name="l00804"></a><span class="lineno">  804</span><span class="comment">   * (again, unless zero(), meaning `capacity() == 0`).  In other words, no deallocation occurs, and an allocation</span></div>
<div class="line"><a id="l00805" name="l00805"></a><span class="lineno">  805</span><span class="comment">   * occurs only if necessary.  Growing an existing buffer is disallowed.  However, if you want to intentionally</span></div>
<div class="line"><a id="l00806" name="l00806"></a><span class="lineno">  806</span><span class="comment">   * REallocate, then simply first check for `zero() == false` and call make_zero() if that holds; then execute the</span></div>
<div class="line"><a id="l00807" name="l00807"></a><span class="lineno">  807</span><span class="comment">   * `reserve()` as planned.  This is an intentional restriction forcing caller to explicitly allow a relatively slow</span></div>
<div class="line"><a id="l00808" name="l00808"></a><span class="lineno">  808</span><span class="comment">   * reallocation op.  You&#39;ll note a similar suggestion for the other reserve()-using methods/operators.</span></div>
<div class="line"><a id="l00809" name="l00809"></a><span class="lineno">  809</span><span class="comment">   *</span></div>
<div class="line"><a id="l00810" name="l00810"></a><span class="lineno">  810</span><span class="comment">   * Formally: If `capacity &gt;= 1`, and `zero() == true`, then a buffer is allocated; and the internal ownership</span></div>
<div class="line"><a id="l00811" name="l00811"></a><span class="lineno">  811</span><span class="comment">   * ref-count is set to 1.</span></div>
<div class="line"><a id="l00812" name="l00812"></a><span class="lineno">  812</span><span class="comment">   *</span></div>
<div class="line"><a id="l00813" name="l00813"></a><span class="lineno">  813</span><span class="comment">   * @param capacity</span></div>
<div class="line"><a id="l00814" name="l00814"></a><span class="lineno">  814</span><span class="comment">   *        Non-negative desired minimum capacity.</span></div>
<div class="line"><a id="l00815" name="l00815"></a><span class="lineno">  815</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00816" name="l00816"></a><span class="lineno">  816</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) or asynchronously when TRACE-logging</span></div>
<div class="line"><a id="l00817" name="l00817"></a><span class="lineno">  817</span><span class="comment">   *        in the event of buffer dealloc.  Null allowed.</span></div>
<div class="line"><a id="l00818" name="l00818"></a><span class="lineno">  818</span><span class="comment">   */</span></div>
<div class="line"><a id="l00819" name="l00819"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aaa7bc2f80b4e46a18f04911954e2b3e7">  819</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#aaa7bc2f80b4e46a18f04911954e2b3e7">reserve</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a719e5c04e4bdc65c31976fc385fd7f24">capacity</a>, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00820" name="l00820"></a><span class="lineno">  820</span><span class="comment"></span> </div>
<div class="line"><a id="l00821" name="l00821"></a><span class="lineno">  821</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00822" name="l00822"></a><span class="lineno">  822</span><span class="comment">   * Guarantees post-condition `zero() == true` by dropping `*this` ownership of the allocated internal buffer if any;</span></div>
<div class="line"><a id="l00823" name="l00823"></a><span class="lineno">  823</span><span class="comment">   * if no other Basic_blob holds ownership of that buffer, then that buffer is deallocated also.  Recall that</span></div>
<div class="line"><a id="l00824" name="l00824"></a><span class="lineno">  824</span><span class="comment">   * other `Basic_blob`s can only gain co-ownership via `share*()`; hence if one does not use that feature, make_zero()</span></div>
<div class="line"><a id="l00825" name="l00825"></a><span class="lineno">  825</span><span class="comment">   * will in fact deallocate the buffer (if any).</span></div>
<div class="line"><a id="l00826" name="l00826"></a><span class="lineno">  826</span><span class="comment">   *</span></div>
<div class="line"><a id="l00827" name="l00827"></a><span class="lineno">  827</span><span class="comment">   * That post-condition can also be thought of as `*this` becoming indistinguishable from a default-constructed</span></div>
<div class="line"><a id="l00828" name="l00828"></a><span class="lineno">  828</span><span class="comment">   * Basic_blob.</span></div>
<div class="line"><a id="l00829" name="l00829"></a><span class="lineno">  829</span><span class="comment">   *</span></div>
<div class="line"><a id="l00830" name="l00830"></a><span class="lineno">  830</span><span class="comment">   * Performance/behavior: Assuming zero() is not already `true`, this will deallocate capacity() sized buffer</span></div>
<div class="line"><a id="l00831" name="l00831"></a><span class="lineno">  831</span><span class="comment">   * and save a null pointer.</span></div>
<div class="line"><a id="l00832" name="l00832"></a><span class="lineno">  832</span><span class="comment">   *</span></div>
<div class="line"><a id="l00833" name="l00833"></a><span class="lineno">  833</span><span class="comment">   * The many operations that involve reserve() in their doc headers will explain importance of this method:</span></div>
<div class="line"><a id="l00834" name="l00834"></a><span class="lineno">  834</span><span class="comment">   * As a rule, no method except make_zero() allows one to request an ownership-drop or deallocation of the existing</span></div>
<div class="line"><a id="l00835" name="l00835"></a><span class="lineno">  835</span><span class="comment">   * buffer, even if this would be necessary for a larger buffer to be allocated.  Therefore, if you intentionally want</span></div>
<div class="line"><a id="l00836" name="l00836"></a><span class="lineno">  836</span><span class="comment">   * to allow such an operation, you CAN, but then you MUST explicitly call make_zero() first.</span></div>
<div class="line"><a id="l00837" name="l00837"></a><span class="lineno">  837</span><span class="comment">   *</span></div>
<div class="line"><a id="l00838" name="l00838"></a><span class="lineno">  838</span><span class="comment">   * Formally: If `!zero()`, then the internal ownership ref-count is decremented by 1, and if it reaches</span></div>
<div class="line"><a id="l00839" name="l00839"></a><span class="lineno">  839</span><span class="comment">   * 0, then a buffer is deallocated.</span></div>
<div class="line"><a id="l00840" name="l00840"></a><span class="lineno">  840</span><span class="comment">   *</span></div>
<div class="line"><a id="l00841" name="l00841"></a><span class="lineno">  841</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00842" name="l00842"></a><span class="lineno">  842</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) only.  Null allowed.</span></div>
<div class="line"><a id="l00843" name="l00843"></a><span class="lineno">  843</span><span class="comment">   */</span></div>
<div class="line"><a id="l00844" name="l00844"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#acf4d5acf2bdde5e602dd2f9d305adebf">  844</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#acf4d5acf2bdde5e602dd2f9d305adebf">make_zero</a>(<a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00845" name="l00845"></a><span class="lineno">  845</span><span class="comment"></span> </div>
<div class="line"><a id="l00846" name="l00846"></a><span class="lineno">  846</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00847" name="l00847"></a><span class="lineno">  847</span><span class="comment">   * Guarantees post-condition `size() == size` and `start() == start`; no values in pre-call range `[begin(), end())`</span></div>
<div class="line"><a id="l00848" name="l00848"></a><span class="lineno">  848</span><span class="comment">   * are changed; any values *added* to that range by the call are not initialized to zero or otherwise.</span></div>
<div class="line"><a id="l00849" name="l00849"></a><span class="lineno">  849</span><span class="comment">   *</span></div>
<div class="line"><a id="l00850" name="l00850"></a><span class="lineno">  850</span><span class="comment">   * From other invariants and behaviors described, you&#39;ll realize</span></div>
<div class="line"><a id="l00851" name="l00851"></a><span class="lineno">  851</span><span class="comment">   * this essentially means `reserve(size + start)` followed by saving `size` and `start` into internal size members.</span></div>
<div class="line"><a id="l00852" name="l00852"></a><span class="lineno">  852</span><span class="comment">   * The various implications of this can be deduced by reading the related methods&#39; doc headers.  The key is to</span></div>
<div class="line"><a id="l00853" name="l00853"></a><span class="lineno">  853</span><span class="comment">   * understand how reserve() works, including what it disallows (growth in size of an existing buffer).</span></div>
<div class="line"><a id="l00854" name="l00854"></a><span class="lineno">  854</span><span class="comment">   *</span></div>
<div class="line"><a id="l00855" name="l00855"></a><span class="lineno">  855</span><span class="comment">   * Formally: If `size &gt;= 1`, and `zero() == true`, then a buffer is allocated; and the internal ownership</span></div>
<div class="line"><a id="l00856" name="l00856"></a><span class="lineno">  856</span><span class="comment">   * ref-count is set to 1.</span></div>
<div class="line"><a id="l00857" name="l00857"></a><span class="lineno">  857</span><span class="comment">   *</span></div>
<div class="line"><a id="l00858" name="l00858"></a><span class="lineno">  858</span><span class="comment">   * ### Leaving start() unmodified ###</span></div>
<div class="line"><a id="l00859" name="l00859"></a><span class="lineno">  859</span><span class="comment">   * `start` is taken to be the value of arg `start_or_unchanged`; unless the latter is set to special value</span></div>
<div class="line"><a id="l00860" name="l00860"></a><span class="lineno">  860</span><span class="comment">   * #S_UNCHANGED; in which case `start` is taken to equal start().  Since the default is indeed #S_UNCHANGED,</span></div>
<div class="line"><a id="l00861" name="l00861"></a><span class="lineno">  861</span><span class="comment">   * the oft-encountered expression `resize(N)` will adjust only size() and leave start() unmodified -- often the</span></div>
<div class="line"><a id="l00862" name="l00862"></a><span class="lineno">  862</span><span class="comment">   * desired behavior.</span></div>
<div class="line"><a id="l00863" name="l00863"></a><span class="lineno">  863</span><span class="comment">   *</span></div>
<div class="line"><a id="l00864" name="l00864"></a><span class="lineno">  864</span><span class="comment">   * @param size</span></div>
<div class="line"><a id="l00865" name="l00865"></a><span class="lineno">  865</span><span class="comment">   *        Non-negative desired value for size().</span></div>
<div class="line"><a id="l00866" name="l00866"></a><span class="lineno">  866</span><span class="comment">   * @param start_or_unchanged</span></div>
<div class="line"><a id="l00867" name="l00867"></a><span class="lineno">  867</span><span class="comment">   *        Non-negative desired value for start(); or special value #S_UNCHANGED.  See above.</span></div>
<div class="line"><a id="l00868" name="l00868"></a><span class="lineno">  868</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l00869" name="l00869"></a><span class="lineno">  869</span><span class="comment">   *        The Logger implementation to use in *this* routine (synchronously) or asynchronously when TRACE-logging</span></div>
<div class="line"><a id="l00870" name="l00870"></a><span class="lineno">  870</span><span class="comment">   *        in the event of buffer dealloc.  Null allowed.</span></div>
<div class="line"><a id="l00871" name="l00871"></a><span class="lineno">  871</span><span class="comment">   */</span></div>
<div class="line"><a id="l00872" name="l00872"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a30b8db540e6d8e6a0b6200c17cf45b60">  872</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a30b8db540e6d8e6a0b6200c17cf45b60">resize</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">size</a>, <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> start_or_unchanged = <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#a7667397ae554e4a9dcb9a3bf1bf33eb8">S_UNCHANGED</a>, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr = <span class="keyword">nullptr</span>);</div>
<div class="line"><a id="l00873" name="l00873"></a><span class="lineno">  873</span><span class="comment"></span> </div>
<div class="line"><a id="l00874" name="l00874"></a><span class="lineno">  874</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00875" name="l00875"></a><span class="lineno">  875</span><span class="comment">   * Restructures blob to consist of an internally allocated buffer and a `[begin(), end)` range starting at</span></div>
<div class="line"><a id="l00876" name="l00876"></a><span class="lineno">  876</span><span class="comment">   * offset `prefix_size` within that buffer.  More formally, it is a simple resize() wrapper that ensures</span></div>
<div class="line"><a id="l00877" name="l00877"></a><span class="lineno">  877</span><span class="comment">   * the internally allocated buffer remains unchanged or, if none is currently large enough to</span></div>
<div class="line"><a id="l00878" name="l00878"></a><span class="lineno">  878</span><span class="comment">   * store `prefix_size` elements, is allocated to be of size `prefix_size`; and that `start() == prefix_size`.</span></div>
<div class="line"><a id="l00879" name="l00879"></a><span class="lineno">  879</span><span class="comment">   *</span></div>
<div class="line"><a id="l00880" name="l00880"></a><span class="lineno">  880</span><span class="comment">   * All of resize()&#39;s behavior, particularly any restrictions about capacity() growth, applies, so in particular</span></div>
<div class="line"><a id="l00881" name="l00881"></a><span class="lineno">  881</span><span class="comment">   * remember you may need to first make_zero() if the internal buffer would need to be REallocated to satisfy the</span></div>
<div class="line"><a id="l00882" name="l00882"></a><span class="lineno">  882</span><span class="comment">   * above requirements.</span></div>
<div class="line"><a id="l00883" name="l00883"></a><span class="lineno">  883</span><span class="comment">   *</span></div>
<div class="line"><a id="l00884" name="l00884"></a><span class="lineno">  884</span><span class="comment">   * In practice, with current reserve() (and thus resize()) restrictions -- which are intentional -- this method is</span></div>
<div class="line"><a id="l00885" name="l00885"></a><span class="lineno">  885</span><span class="comment">   * most useful if you already have a Basic_blob with internally allocated buffer of size *at least*</span></div>
<div class="line"><a id="l00886" name="l00886"></a><span class="lineno">  886</span><span class="comment">   * `n == size() + start()` (and `start() == 0` for simplicity), and you&#39;d like to treat this buffer as containing</span></div>
<div class="line"><a id="l00887" name="l00887"></a><span class="lineno">  887</span><span class="comment">   * no-longer-relevant prefix of length S (which becomes new value for start()) and have size() be readjusted down</span></div>
<div class="line"><a id="l00888" name="l00888"></a><span class="lineno">  888</span><span class="comment">   * accordingly, while `start() + size() == n` remains unchaged.  If the buffer also contains irrelevant data</span></div>
<div class="line"><a id="l00889" name="l00889"></a><span class="lineno">  889</span><span class="comment">   * *past* a certain offset N, you can first make it irrelevant via `resize(N)` (then call `start_past_prefix(S)`</span></div>
<div class="line"><a id="l00890" name="l00890"></a><span class="lineno">  890</span><span class="comment">   * as just described):</span></div>
<div class="line"><a id="l00891" name="l00891"></a><span class="lineno">  891</span><span class="comment">   *</span></div>
<div class="line"><a id="l00892" name="l00892"></a><span class="lineno">  892</span><span class="comment">   *   ~~~</span></div>
<div class="line"><a id="l00893" name="l00893"></a><span class="lineno">  893</span><span class="comment">   *   Basic_blob b;</span></div>
<div class="line"><a id="l00894" name="l00894"></a><span class="lineno">  894</span><span class="comment">   *   // ...</span></div>
<div class="line"><a id="l00895" name="l00895"></a><span class="lineno">  895</span><span class="comment">   *   // b now has start() == 0, size() == M.</span></div>
<div class="line"><a id="l00896" name="l00896"></a><span class="lineno">  896</span><span class="comment">   *   // We want all elements outside [S, N] to be irrelevant, where S &gt; 0, N &lt; M.</span></div>
<div class="line"><a id="l00897" name="l00897"></a><span class="lineno">  897</span><span class="comment">   *   // (E.g., first S are a frame prefix, while all bytes past N are a frame postfix, and we want just the frame</span></div>
<div class="line"><a id="l00898" name="l00898"></a><span class="lineno">  898</span><span class="comment">   *   // without any reallocating or copying.)</span></div>
<div class="line"><a id="l00899" name="l00899"></a><span class="lineno">  899</span><span class="comment">   *   b.resize(N);</span></div>
<div class="line"><a id="l00900" name="l00900"></a><span class="lineno">  900</span><span class="comment">   *   b.start_past_prefix(S);</span></div>
<div class="line"><a id="l00901" name="l00901"></a><span class="lineno">  901</span><span class="comment">   *   // Now, [b.begin(), b.end()) are the frame bytes, and no copying/allocation/deallocation has occurred.</span></div>
<div class="line"><a id="l00902" name="l00902"></a><span class="lineno">  902</span><span class="comment">   *   ~~~</span></div>
<div class="line"><a id="l00903" name="l00903"></a><span class="lineno">  903</span><span class="comment">   *</span></div>
<div class="line"><a id="l00904" name="l00904"></a><span class="lineno">  904</span><span class="comment">   * @param prefix_size</span></div>
<div class="line"><a id="l00905" name="l00905"></a><span class="lineno">  905</span><span class="comment">   *        Desired prefix length.  `prefix_size == 0` is allowed and is a degenerate case equivalent to:</span></div>
<div class="line"><a id="l00906" name="l00906"></a><span class="lineno">  906</span><span class="comment">   *        `resize(start() + size(), 0)`.</span></div>
<div class="line"><a id="l00907" name="l00907"></a><span class="lineno">  907</span><span class="comment">   */</span></div>
<div class="line"><a id="l00908" name="l00908"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#af98832169c8e46d84f6c06987a3670e3">  908</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#af98832169c8e46d84f6c06987a3670e3">start_past_prefix</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> prefix_size);</div>
<div class="line"><a id="l00909" name="l00909"></a><span class="lineno">  909</span><span class="comment"></span> </div>
<div class="line"><a id="l00910" name="l00910"></a><span class="lineno">  910</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00911" name="l00911"></a><span class="lineno">  911</span><span class="comment">   * Like start_past_prefix() but shifts the *current* prefix position by the given *incremental* value</span></div>
<div class="line"><a id="l00912" name="l00912"></a><span class="lineno">  912</span><span class="comment">   * (positive or negative).  Identical to `start_past_prefix(start() + prefix_size_inc)`.</span></div>
<div class="line"><a id="l00913" name="l00913"></a><span class="lineno">  913</span><span class="comment">   *</span></div>
<div class="line"><a id="l00914" name="l00914"></a><span class="lineno">  914</span><span class="comment">   * Behavior is undefined for negative `prefix_size_inc` whose magnitue exceeds start() (assertion may trip).</span></div>
<div class="line"><a id="l00915" name="l00915"></a><span class="lineno">  915</span><span class="comment">   *</span></div>
<div class="line"><a id="l00916" name="l00916"></a><span class="lineno">  916</span><span class="comment">   * Behavior is undefined in case of positive `prefix_size_inc` that results in overflow.</span></div>
<div class="line"><a id="l00917" name="l00917"></a><span class="lineno">  917</span><span class="comment">   *</span></div>
<div class="line"><a id="l00918" name="l00918"></a><span class="lineno">  918</span><span class="comment">   * @param prefix_size_inc</span></div>
<div class="line"><a id="l00919" name="l00919"></a><span class="lineno">  919</span><span class="comment">   *        Positive, negative (or zero) increment, so that start() is changed to `start() + prefix_size_inc`.</span></div>
<div class="line"><a id="l00920" name="l00920"></a><span class="lineno">  920</span><span class="comment">   */</span></div>
<div class="line"><a id="l00921" name="l00921"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a9c3497d662be650e7a560eb7a703acc1">  921</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9c3497d662be650e7a560eb7a703acc1">start_past_prefix_inc</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a614d9cd750d8db928b4d1e045ef15c56">difference_type</a> prefix_size_inc);</div>
<div class="line"><a id="l00922" name="l00922"></a><span class="lineno">  922</span><span class="comment"></span> </div>
<div class="line"><a id="l00923" name="l00923"></a><span class="lineno">  923</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00924" name="l00924"></a><span class="lineno">  924</span><span class="comment">   * Equivalent to `resize(0, start())`.</span></div>
<div class="line"><a id="l00925" name="l00925"></a><span class="lineno">  925</span><span class="comment">   *</span></div>
<div class="line"><a id="l00926" name="l00926"></a><span class="lineno">  926</span><span class="comment">   * Note that the value returned by start() will *not* change due to this call.  Only size() (and the corresponding</span></div>
<div class="line"><a id="l00927" name="l00927"></a><span class="lineno">  927</span><span class="comment">   * internally stored datum) may change.  If one desires to reset start(), use resize() directly (but if one</span></div>
<div class="line"><a id="l00928" name="l00928"></a><span class="lineno">  928</span><span class="comment">   * plans to work on a sub-Basic_blob of a shared pool -- see class doc header -- please think twice first).</span></div>
<div class="line"><a id="l00929" name="l00929"></a><span class="lineno">  929</span><span class="comment">   */</span></div>
<div class="line"><a id="l00930" name="l00930"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a62da4400fbde6c186fb989f55248e3d2">  930</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a62da4400fbde6c186fb989f55248e3d2">clear</a>();</div>
<div class="line"><a id="l00931" name="l00931"></a><span class="lineno">  931</span><span class="comment"></span> </div>
<div class="line"><a id="l00932" name="l00932"></a><span class="lineno">  932</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00933" name="l00933"></a><span class="lineno">  933</span><span class="comment">   * Performs the minimal number of operations to make range `[begin(), end())` unchanged except for lacking</span></div>
<div class="line"><a id="l00934" name="l00934"></a><span class="lineno">  934</span><span class="comment">   * sub-range `[first, past_last)`.</span></div>
<div class="line"><a id="l00935" name="l00935"></a><span class="lineno">  935</span><span class="comment">   *</span></div>
<div class="line"><a id="l00936" name="l00936"></a><span class="lineno">  936</span><span class="comment">   * Performance/behavior: At most, this copies the range `[past_last, end())` to area starting at `first`;</span></div>
<div class="line"><a id="l00937" name="l00937"></a><span class="lineno">  937</span><span class="comment">   * and then adjusts internally stored size member.</span></div>
<div class="line"><a id="l00938" name="l00938"></a><span class="lineno">  938</span><span class="comment">   *</span></div>
<div class="line"><a id="l00939" name="l00939"></a><span class="lineno">  939</span><span class="comment">   * @param first</span></div>
<div class="line"><a id="l00940" name="l00940"></a><span class="lineno">  940</span><span class="comment">   *        Pointer to first element to erase.  It must be dereferenceable, or behavior is undefined (assertion may</span></div>
<div class="line"><a id="l00941" name="l00941"></a><span class="lineno">  941</span><span class="comment">   *        trip).</span></div>
<div class="line"><a id="l00942" name="l00942"></a><span class="lineno">  942</span><span class="comment">   * @param past_last</span></div>
<div class="line"><a id="l00943" name="l00943"></a><span class="lineno">  943</span><span class="comment">   *        Pointer to one past the last element to erase.  If `past_last &lt;= first`, call is a no-op.</span></div>
<div class="line"><a id="l00944" name="l00944"></a><span class="lineno">  944</span><span class="comment">   * @return Iterator equal to `first`.  (This matches standard expectation for container `erase()` return value:</span></div>
<div class="line"><a id="l00945" name="l00945"></a><span class="lineno">  945</span><span class="comment">   *         iterator to element past the last one erased.  In this contiguous sequence that simply equals `first`,</span></div>
<div class="line"><a id="l00946" name="l00946"></a><span class="lineno">  946</span><span class="comment">   *         since everything starting with `past_last` slides left onto `first`.  In particular:</span></div>
<div class="line"><a id="l00947" name="l00947"></a><span class="lineno">  947</span><span class="comment">   *         If `past_last()` equaled `end()` at entry, then the new end() is returned: everything starting with</span></div>
<div class="line"><a id="l00948" name="l00948"></a><span class="lineno">  948</span><span class="comment">   *         `first` was erased and thus `first == end()` now.  If nothing is erased `first` is still returned.)</span></div>
<div class="line"><a id="l00949" name="l00949"></a><span class="lineno">  949</span><span class="comment">   */</span></div>
<div class="line"><a id="l00950" name="l00950"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a49046a070b040ca17ca9062ac291a6dd">  950</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a49046a070b040ca17ca9062ac291a6dd">erase</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> first, <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> past_last);</div>
<div class="line"><a id="l00951" name="l00951"></a><span class="lineno">  951</span><span class="comment"></span> </div>
<div class="line"><a id="l00952" name="l00952"></a><span class="lineno">  952</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00953" name="l00953"></a><span class="lineno">  953</span><span class="comment">   * Returns pointer to mutable first element; or end() if empty().  Null is a possible value in the latter case.</span></div>
<div class="line"><a id="l00954" name="l00954"></a><span class="lineno">  954</span><span class="comment">   *</span></div>
<div class="line"><a id="l00955" name="l00955"></a><span class="lineno">  955</span><span class="comment">   * @return Pointer, possibly null.</span></div>
<div class="line"><a id="l00956" name="l00956"></a><span class="lineno">  956</span><span class="comment">   */</span></div>
<div class="line"><a id="l00957" name="l00957"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a9daa427a42c8a8c24b585f96c37d277a">  957</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9daa427a42c8a8c24b585f96c37d277a">begin</a>();</div>
<div class="line"><a id="l00958" name="l00958"></a><span class="lineno">  958</span><span class="comment"></span> </div>
<div class="line"><a id="l00959" name="l00959"></a><span class="lineno">  959</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00960" name="l00960"></a><span class="lineno">  960</span><span class="comment">   * Returns pointer to immutable first element; or end() if empty().  Null is a possible value in the latter case.</span></div>
<div class="line"><a id="l00961" name="l00961"></a><span class="lineno">  961</span><span class="comment">   *</span></div>
<div class="line"><a id="l00962" name="l00962"></a><span class="lineno">  962</span><span class="comment">   * @return Pointer, possibly null.</span></div>
<div class="line"><a id="l00963" name="l00963"></a><span class="lineno">  963</span><span class="comment">   */</span></div>
<div class="line"><a id="l00964" name="l00964"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ac511ddaa3fb453888524cedba39c36ef">  964</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ac511ddaa3fb453888524cedba39c36ef">const_begin</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l00965" name="l00965"></a><span class="lineno">  965</span><span class="comment"></span> </div>
<div class="line"><a id="l00966" name="l00966"></a><span class="lineno">  966</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00967" name="l00967"></a><span class="lineno">  967</span><span class="comment">   * Equivalent to const_begin().</span></div>
<div class="line"><a id="l00968" name="l00968"></a><span class="lineno">  968</span><span class="comment">   *</span></div>
<div class="line"><a id="l00969" name="l00969"></a><span class="lineno">  969</span><span class="comment">   * @return Pointer, possibly null.</span></div>
<div class="line"><a id="l00970" name="l00970"></a><span class="lineno">  970</span><span class="comment">   */</span></div>
<div class="line"><a id="l00971" name="l00971"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a1dfd46fca324a6b80934b9230c2f2bb4">  971</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a1dfd46fca324a6b80934b9230c2f2bb4">begin</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l00972" name="l00972"></a><span class="lineno">  972</span><span class="comment"></span> </div>
<div class="line"><a id="l00973" name="l00973"></a><span class="lineno">  973</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00974" name="l00974"></a><span class="lineno">  974</span><span class="comment">   * Returns pointer one past mutable last element; empty() is possible.  Null is a possible value in the latter case.</span></div>
<div class="line"><a id="l00975" name="l00975"></a><span class="lineno">  975</span><span class="comment">   *</span></div>
<div class="line"><a id="l00976" name="l00976"></a><span class="lineno">  976</span><span class="comment">   * @return Pointer, possibly null.</span></div>
<div class="line"><a id="l00977" name="l00977"></a><span class="lineno">  977</span><span class="comment">   */</span></div>
<div class="line"><a id="l00978" name="l00978"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a61880291749335246f60fde4387f7ad6">  978</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a61880291749335246f60fde4387f7ad6">end</a>();</div>
<div class="line"><a id="l00979" name="l00979"></a><span class="lineno">  979</span><span class="comment"></span> </div>
<div class="line"><a id="l00980" name="l00980"></a><span class="lineno">  980</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00981" name="l00981"></a><span class="lineno">  981</span><span class="comment">   * Returns pointer one past immutable last element; empty() is possible.  Null is a possible value in the latter case.</span></div>
<div class="line"><a id="l00982" name="l00982"></a><span class="lineno">  982</span><span class="comment">   *</span></div>
<div class="line"><a id="l00983" name="l00983"></a><span class="lineno">  983</span><span class="comment">   * @return Pointer, possibly null.</span></div>
<div class="line"><a id="l00984" name="l00984"></a><span class="lineno">  984</span><span class="comment">   */</span></div>
<div class="line"><a id="l00985" name="l00985"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ae4f1d8c42aea63ba4f127cb7ed5776d6">  985</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ae4f1d8c42aea63ba4f127cb7ed5776d6">const_end</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l00986" name="l00986"></a><span class="lineno">  986</span><span class="comment"></span> </div>
<div class="line"><a id="l00987" name="l00987"></a><span class="lineno">  987</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00988" name="l00988"></a><span class="lineno">  988</span><span class="comment">   * Equivalent to const_end().</span></div>
<div class="line"><a id="l00989" name="l00989"></a><span class="lineno">  989</span><span class="comment">   *</span></div>
<div class="line"><a id="l00990" name="l00990"></a><span class="lineno">  990</span><span class="comment">   * @return Pointer, possibly null.</span></div>
<div class="line"><a id="l00991" name="l00991"></a><span class="lineno">  991</span><span class="comment">   */</span></div>
<div class="line"><a id="l00992" name="l00992"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a9b61c80d3df1c53583362ec15cdbb0b6">  992</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9b61c80d3df1c53583362ec15cdbb0b6">end</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l00993" name="l00993"></a><span class="lineno">  993</span><span class="comment"></span> </div>
<div class="line"><a id="l00994" name="l00994"></a><span class="lineno">  994</span><span class="comment">  /**</span></div>
<div class="line"><a id="l00995" name="l00995"></a><span class="lineno">  995</span><span class="comment">   * Returns reference to immutable first element.  Behavior is undefined if empty().</span></div>
<div class="line"><a id="l00996" name="l00996"></a><span class="lineno">  996</span><span class="comment">   *</span></div>
<div class="line"><a id="l00997" name="l00997"></a><span class="lineno">  997</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l00998" name="l00998"></a><span class="lineno">  998</span><span class="comment">   */</span></div>
<div class="line"><a id="l00999" name="l00999"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a90859b0e130bef705a2e556ccb27df53">  999</a></span>  <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a90859b0e130bef705a2e556ccb27df53">const_front</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l01000" name="l01000"></a><span class="lineno"> 1000</span><span class="comment"></span> </div>
<div class="line"><a id="l01001" name="l01001"></a><span class="lineno"> 1001</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01002" name="l01002"></a><span class="lineno"> 1002</span><span class="comment">   * Returns reference to immutable last element.  Behavior is undefined if empty().</span></div>
<div class="line"><a id="l01003" name="l01003"></a><span class="lineno"> 1003</span><span class="comment">   *</span></div>
<div class="line"><a id="l01004" name="l01004"></a><span class="lineno"> 1004</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l01005" name="l01005"></a><span class="lineno"> 1005</span><span class="comment">   */</span></div>
<div class="line"><a id="l01006" name="l01006"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a7c99b053ce77cd0573d882e194908e49"> 1006</a></span>  <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a7c99b053ce77cd0573d882e194908e49">const_back</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l01007" name="l01007"></a><span class="lineno"> 1007</span><span class="comment"></span> </div>
<div class="line"><a id="l01008" name="l01008"></a><span class="lineno"> 1008</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01009" name="l01009"></a><span class="lineno"> 1009</span><span class="comment">   * Equivalent to const_front().</span></div>
<div class="line"><a id="l01010" name="l01010"></a><span class="lineno"> 1010</span><span class="comment">   *</span></div>
<div class="line"><a id="l01011" name="l01011"></a><span class="lineno"> 1011</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l01012" name="l01012"></a><span class="lineno"> 1012</span><span class="comment">   */</span></div>
<div class="line"><a id="l01013" name="l01013"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a98a489088e29d5d4b82b0498c8e210f8"> 1013</a></span>  <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a98a489088e29d5d4b82b0498c8e210f8">front</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l01014" name="l01014"></a><span class="lineno"> 1014</span><span class="comment"></span> </div>
<div class="line"><a id="l01015" name="l01015"></a><span class="lineno"> 1015</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01016" name="l01016"></a><span class="lineno"> 1016</span><span class="comment">   * Equivalent to const_back().</span></div>
<div class="line"><a id="l01017" name="l01017"></a><span class="lineno"> 1017</span><span class="comment">   *</span></div>
<div class="line"><a id="l01018" name="l01018"></a><span class="lineno"> 1018</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l01019" name="l01019"></a><span class="lineno"> 1019</span><span class="comment">   */</span></div>
<div class="line"><a id="l01020" name="l01020"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ac10980e7748d8198fe831666254d864d"> 1020</a></span>  <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ac10980e7748d8198fe831666254d864d">back</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l01021" name="l01021"></a><span class="lineno"> 1021</span><span class="comment"></span> </div>
<div class="line"><a id="l01022" name="l01022"></a><span class="lineno"> 1022</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01023" name="l01023"></a><span class="lineno"> 1023</span><span class="comment">   * Returns reference to mutable first element.  Behavior is undefined if empty().</span></div>
<div class="line"><a id="l01024" name="l01024"></a><span class="lineno"> 1024</span><span class="comment">   *</span></div>
<div class="line"><a id="l01025" name="l01025"></a><span class="lineno"> 1025</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l01026" name="l01026"></a><span class="lineno"> 1026</span><span class="comment">   */</span></div>
<div class="line"><a id="l01027" name="l01027"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#abe7ea8c6aa0a7b043129fca8eacaedad"> 1027</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#abe7ea8c6aa0a7b043129fca8eacaedad">front</a>();</div>
<div class="line"><a id="l01028" name="l01028"></a><span class="lineno"> 1028</span><span class="comment"></span> </div>
<div class="line"><a id="l01029" name="l01029"></a><span class="lineno"> 1029</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01030" name="l01030"></a><span class="lineno"> 1030</span><span class="comment">   * Returns reference to mutable last element.  Behavior is undefined if empty().</span></div>
<div class="line"><a id="l01031" name="l01031"></a><span class="lineno"> 1031</span><span class="comment">   *</span></div>
<div class="line"><a id="l01032" name="l01032"></a><span class="lineno"> 1032</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l01033" name="l01033"></a><span class="lineno"> 1033</span><span class="comment">   */</span></div>
<div class="line"><a id="l01034" name="l01034"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a49d05eed39be69ceec235fe3403b16b9"> 1034</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a49d05eed39be69ceec235fe3403b16b9">back</a>();</div>
<div class="line"><a id="l01035" name="l01035"></a><span class="lineno"> 1035</span><span class="comment"></span> </div>
<div class="line"><a id="l01036" name="l01036"></a><span class="lineno"> 1036</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01037" name="l01037"></a><span class="lineno"> 1037</span><span class="comment">   * Equivalent to const_begin().</span></div>
<div class="line"><a id="l01038" name="l01038"></a><span class="lineno"> 1038</span><span class="comment">   *</span></div>
<div class="line"><a id="l01039" name="l01039"></a><span class="lineno"> 1039</span><span class="comment">   * @return Pointer, possibly null.</span></div>
<div class="line"><a id="l01040" name="l01040"></a><span class="lineno"> 1040</span><span class="comment">   */</span></div>
<div class="line"><a id="l01041" name="l01041"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a75d4c0a1e530596982a3b5d3e0ff91e6"> 1041</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a> <span class="keyword">const</span> * <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a75d4c0a1e530596982a3b5d3e0ff91e6">const_data</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l01042" name="l01042"></a><span class="lineno"> 1042</span><span class="comment"></span> </div>
<div class="line"><a id="l01043" name="l01043"></a><span class="lineno"> 1043</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01044" name="l01044"></a><span class="lineno"> 1044</span><span class="comment">   * Equivalent to begin().</span></div>
<div class="line"><a id="l01045" name="l01045"></a><span class="lineno"> 1045</span><span class="comment">   *</span></div>
<div class="line"><a id="l01046" name="l01046"></a><span class="lineno"> 1046</span><span class="comment">   * @return Pointer, possibly null.</span></div>
<div class="line"><a id="l01047" name="l01047"></a><span class="lineno"> 1047</span><span class="comment">   */</span></div>
<div class="line"><a id="l01048" name="l01048"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a4581e779dace3d64fe4098eb0a7dbeb2"> 1048</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>* <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a4581e779dace3d64fe4098eb0a7dbeb2">data</a>();</div>
<div class="line"><a id="l01049" name="l01049"></a><span class="lineno"> 1049</span><span class="comment"></span> </div>
<div class="line"><a id="l01050" name="l01050"></a><span class="lineno"> 1050</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01051" name="l01051"></a><span class="lineno"> 1051</span><span class="comment">   * Synonym of const_begin().  Exists as standard container method (hence the odd formatting).</span></div>
<div class="line"><a id="l01052" name="l01052"></a><span class="lineno"> 1052</span><span class="comment">   *</span></div>
<div class="line"><a id="l01053" name="l01053"></a><span class="lineno"> 1053</span><span class="comment">   * @return See const_begin().</span></div>
<div class="line"><a id="l01054" name="l01054"></a><span class="lineno"> 1054</span><span class="comment">   */</span></div>
<div class="line"><a id="l01055" name="l01055"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a669252f9a78f516dfeaf964987078255"> 1055</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a669252f9a78f516dfeaf964987078255">cbegin</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l01056" name="l01056"></a><span class="lineno"> 1056</span><span class="comment"></span> </div>
<div class="line"><a id="l01057" name="l01057"></a><span class="lineno"> 1057</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01058" name="l01058"></a><span class="lineno"> 1058</span><span class="comment">   * Synonym of const_end().  Exists as standard container method (hence the odd formatting).</span></div>
<div class="line"><a id="l01059" name="l01059"></a><span class="lineno"> 1059</span><span class="comment">   *</span></div>
<div class="line"><a id="l01060" name="l01060"></a><span class="lineno"> 1060</span><span class="comment">   * @return See const_end().</span></div>
<div class="line"><a id="l01061" name="l01061"></a><span class="lineno"> 1061</span><span class="comment">   */</span></div>
<div class="line"><a id="l01062" name="l01062"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ada9e80920dcc3d51c229db98a9d62ac6"> 1062</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ada9e80920dcc3d51c229db98a9d62ac6">cend</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l01063" name="l01063"></a><span class="lineno"> 1063</span><span class="comment"></span> </div>
<div class="line"><a id="l01064" name="l01064"></a><span class="lineno"> 1064</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01065" name="l01065"></a><span class="lineno"> 1065</span><span class="comment">   * Returns `true` if and only if: `this-&gt;derefable_iterator(it) || (it == this-&gt;const_end())`.</span></div>
<div class="line"><a id="l01066" name="l01066"></a><span class="lineno"> 1066</span><span class="comment">   *</span></div>
<div class="line"><a id="l01067" name="l01067"></a><span class="lineno"> 1067</span><span class="comment">   * @param it</span></div>
<div class="line"><a id="l01068" name="l01068"></a><span class="lineno"> 1068</span><span class="comment">   *        Iterator/pointer to check.</span></div>
<div class="line"><a id="l01069" name="l01069"></a><span class="lineno"> 1069</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l01070" name="l01070"></a><span class="lineno"> 1070</span><span class="comment">   */</span></div>
<div class="line"><a id="l01071" name="l01071"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a73e09b11e0067730db64f1fac7620a04"> 1071</a></span>  <span class="keywordtype">bool</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a73e09b11e0067730db64f1fac7620a04">valid_iterator</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> it) <span class="keyword">const</span>;</div>
<div class="line"><a id="l01072" name="l01072"></a><span class="lineno"> 1072</span><span class="comment"></span> </div>
<div class="line"><a id="l01073" name="l01073"></a><span class="lineno"> 1073</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01074" name="l01074"></a><span class="lineno"> 1074</span><span class="comment">   * Returns `true` if and only if the given iterator points to an element within this blob&#39;s size() elements.</span></div>
<div class="line"><a id="l01075" name="l01075"></a><span class="lineno"> 1075</span><span class="comment">   * In particular, this is always `false` if empty(); and also when `it == this-&gt;const_end()`.</span></div>
<div class="line"><a id="l01076" name="l01076"></a><span class="lineno"> 1076</span><span class="comment">   *</span></div>
<div class="line"><a id="l01077" name="l01077"></a><span class="lineno"> 1077</span><span class="comment">   * @param it</span></div>
<div class="line"><a id="l01078" name="l01078"></a><span class="lineno"> 1078</span><span class="comment">   *        Iterator/pointer to check.</span></div>
<div class="line"><a id="l01079" name="l01079"></a><span class="lineno"> 1079</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l01080" name="l01080"></a><span class="lineno"> 1080</span><span class="comment">   */</span></div>
<div class="line"><a id="l01081" name="l01081"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a198eb271d009f153cae041ba1948e945"> 1081</a></span>  <span class="keywordtype">bool</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a198eb271d009f153cae041ba1948e945">derefable_iterator</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> it) <span class="keyword">const</span>;</div>
<div class="line"><a id="l01082" name="l01082"></a><span class="lineno"> 1082</span><span class="comment"></span> </div>
<div class="line"><a id="l01083" name="l01083"></a><span class="lineno"> 1083</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01084" name="l01084"></a><span class="lineno"> 1084</span><span class="comment">   * Convenience accessor returning an immutable boost.asio buffer &quot;view&quot; into the entirety of the blob.</span></div>
<div class="line"><a id="l01085" name="l01085"></a><span class="lineno"> 1085</span><span class="comment">   * Equivalent to `const_buffer(const_data(), size())`.</span></div>
<div class="line"><a id="l01086" name="l01086"></a><span class="lineno"> 1086</span><span class="comment">   *</span></div>
<div class="line"><a id="l01087" name="l01087"></a><span class="lineno"> 1087</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l01088" name="l01088"></a><span class="lineno"> 1088</span><span class="comment">   */</span></div>
<div class="line"><a id="l01089" name="l01089"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#afbb4e2420be2f8ca0dc8c4fb70feb8ea"> 1089</a></span>  boost::asio::const_buffer <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#afbb4e2420be2f8ca0dc8c4fb70feb8ea">const_buffer</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l01090" name="l01090"></a><span class="lineno"> 1090</span><span class="comment"></span> </div>
<div class="line"><a id="l01091" name="l01091"></a><span class="lineno"> 1091</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01092" name="l01092"></a><span class="lineno"> 1092</span><span class="comment">   * Same as const_buffer() but the returned view is mutable.</span></div>
<div class="line"><a id="l01093" name="l01093"></a><span class="lineno"> 1093</span><span class="comment">   * Equivalent to `mutable_buffer(data(), size())`.</span></div>
<div class="line"><a id="l01094" name="l01094"></a><span class="lineno"> 1094</span><span class="comment">   *</span></div>
<div class="line"><a id="l01095" name="l01095"></a><span class="lineno"> 1095</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l01096" name="l01096"></a><span class="lineno"> 1096</span><span class="comment">   */</span></div>
<div class="line"><a id="l01097" name="l01097"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a2bd3cb0b6b3f304fb6fb771c1b76ec66"> 1097</a></span>  boost::asio::mutable_buffer <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a2bd3cb0b6b3f304fb6fb771c1b76ec66">mutable_buffer</a>();</div>
<div class="line"><a id="l01098" name="l01098"></a><span class="lineno"> 1098</span><span class="comment"></span> </div>
<div class="line"><a id="l01099" name="l01099"></a><span class="lineno"> 1099</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01100" name="l01100"></a><span class="lineno"> 1100</span><span class="comment">   * Returns a copy of the internally cached #Allocator_raw as set by a constructor or assign() or</span></div>
<div class="line"><a id="l01101" name="l01101"></a><span class="lineno"> 1101</span><span class="comment">   * assignment-operator, whichever happened last.</span></div>
<div class="line"><a id="l01102" name="l01102"></a><span class="lineno"> 1102</span><span class="comment">   *</span></div>
<div class="line"><a id="l01103" name="l01103"></a><span class="lineno"> 1103</span><span class="comment">   * @return See above.</span></div>
<div class="line"><a id="l01104" name="l01104"></a><span class="lineno"> 1104</span><span class="comment">   */</span></div>
<div class="line"><a id="l01105" name="l01105"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#af32359d0bd98f378c7397a7c86e6e66d"> 1105</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#af32359d0bd98f378c7397a7c86e6e66d">get_allocator</a>() <span class="keyword">const</span>;</div>
<div class="line"><a id="l01106" name="l01106"></a><span class="lineno"> 1106</span> </div>
<div class="line"><a id="l01107" name="l01107"></a><span class="lineno"> 1107</span><span class="keyword">protected</span>:</div>
<div class="line"><a id="l01108" name="l01108"></a><span class="lineno"> 1108</span>  <span class="comment">// Constants.</span></div>
<div class="line"><a id="l01109" name="l01109"></a><span class="lineno"> 1109</span><span class="comment"></span> </div>
<div class="line"><a id="l01110" name="l01110"></a><span class="lineno"> 1110</span><span class="comment">  /// Our flow::log::Component.</span></div>
<div class="line"><a id="l01111" name="l01111"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ad65bfdec2d39f4ccce6c311226b78c5b"> 1111</a></span><span class="comment"></span>  <span class="keyword">static</span> <span class="keyword">constexpr</span> <a class="code hl_enumeration" href="namespaceflow.html#a3938730ab4b89daf13d027a5f620e7ce">Flow_log_component</a> <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#ad65bfdec2d39f4ccce6c311226b78c5b">S_LOG_COMPONENT</a> = Flow_log_component::S_UTIL;</div>
<div class="line"><a id="l01112" name="l01112"></a><span class="lineno"> 1112</span> </div>
<div class="line"><a id="l01113" name="l01113"></a><span class="lineno"> 1113</span>  <span class="comment">// Methods.</span></div>
<div class="line"><a id="l01114" name="l01114"></a><span class="lineno"> 1114</span><span class="comment"></span> </div>
<div class="line"><a id="l01115" name="l01115"></a><span class="lineno"> 1115</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01116" name="l01116"></a><span class="lineno"> 1116</span><span class="comment">   * Impl of share_after_split_equally() but capable of emitting not just `*this` type (`Basic_blob&lt;...&gt;`)</span></div>
<div class="line"><a id="l01117" name="l01117"></a><span class="lineno"> 1117</span><span class="comment">   * but any sub-class (such as `Blob`/`Sharing_blob`) provided a functor like share_after_split_left() but returning</span></div>
<div class="line"><a id="l01118" name="l01118"></a><span class="lineno"> 1118</span><span class="comment">   * an object of that appropriate type.</span></div>
<div class="line"><a id="l01119" name="l01119"></a><span class="lineno"> 1119</span><span class="comment">   *</span></div>
<div class="line"><a id="l01120" name="l01120"></a><span class="lineno"> 1120</span><span class="comment">   * @tparam Emit_blob_func</span></div>
<div class="line"><a id="l01121" name="l01121"></a><span class="lineno"> 1121</span><span class="comment">   *         See share_after_split_equally(); however it is to take the type to emit which can</span></div>
<div class="line"><a id="l01122" name="l01122"></a><span class="lineno"> 1122</span><span class="comment">   *         be `*this` Basic_blob or a sub-class.</span></div>
<div class="line"><a id="l01123" name="l01123"></a><span class="lineno"> 1123</span><span class="comment">   * @tparam Share_after_split_left_func</span></div>
<div class="line"><a id="l01124" name="l01124"></a><span class="lineno"> 1124</span><span class="comment">   *         A callback with signature identical to share_after_split_left() but returning</span></div>
<div class="line"><a id="l01125" name="l01125"></a><span class="lineno"> 1125</span><span class="comment">   *         the same type emitted by `Emit_blob_func`.</span></div>
<div class="line"><a id="l01126" name="l01126"></a><span class="lineno"> 1126</span><span class="comment">   * @param size</span></div>
<div class="line"><a id="l01127" name="l01127"></a><span class="lineno"> 1127</span><span class="comment">   *        See share_after_split_equally().</span></div>
<div class="line"><a id="l01128" name="l01128"></a><span class="lineno"> 1128</span><span class="comment">   * @param headless_pool</span></div>
<div class="line"><a id="l01129" name="l01129"></a><span class="lineno"> 1129</span><span class="comment">   *        See share_after_split_equally().</span></div>
<div class="line"><a id="l01130" name="l01130"></a><span class="lineno"> 1130</span><span class="comment">   * @param emit_blob_func</span></div>
<div class="line"><a id="l01131" name="l01131"></a><span class="lineno"> 1131</span><span class="comment">   *        See `Emit_blob_func`.</span></div>
<div class="line"><a id="l01132" name="l01132"></a><span class="lineno"> 1132</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l01133" name="l01133"></a><span class="lineno"> 1133</span><span class="comment">   *        See share_after_split_equally().</span></div>
<div class="line"><a id="l01134" name="l01134"></a><span class="lineno"> 1134</span><span class="comment">   * @param share_after_split_left_func</span></div>
<div class="line"><a id="l01135" name="l01135"></a><span class="lineno"> 1135</span><span class="comment">   *        See `Share_after_split_left_func`.</span></div>
<div class="line"><a id="l01136" name="l01136"></a><span class="lineno"> 1136</span><span class="comment">   */</span></div>
<div class="line"><a id="l01137" name="l01137"></a><span class="lineno"> 1137</span>  <span class="keyword">template</span>&lt;<span class="keyword">typename</span> Emit_blob_func, <span class="keyword">typename</span> Share_after_split_left_func&gt;</div>
<div class="line"><a id="l01138" name="l01138"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a92215c61d9e3ca83bdbfa6b078b72dc9"> 1138</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a92215c61d9e3ca83bdbfa6b078b72dc9">share_after_split_equally_impl</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">size</a>, <span class="keywordtype">bool</span> headless_pool,</div>
<div class="line"><a id="l01139" name="l01139"></a><span class="lineno"> 1139</span>                                      Emit_blob_func&amp;&amp; emit_blob_func,</div>
<div class="line"><a id="l01140" name="l01140"></a><span class="lineno"> 1140</span>                                      <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr,</div>
<div class="line"><a id="l01141" name="l01141"></a><span class="lineno"> 1141</span>                                      Share_after_split_left_func&amp;&amp; share_after_split_left_func);</div>
<div class="line"><a id="l01142" name="l01142"></a><span class="lineno"> 1142</span> </div>
<div class="line"><a id="l01143" name="l01143"></a><span class="lineno"> 1143</span><span class="keyword">private</span>:</div>
<div class="line"><a id="l01144" name="l01144"></a><span class="lineno"> 1144</span> </div>
<div class="line"><a id="l01145" name="l01145"></a><span class="lineno"> 1145</span>  <span class="comment">// Types.</span></div>
<div class="line"><a id="l01146" name="l01146"></a><span class="lineno"> 1146</span><span class="comment"></span> </div>
<div class="line"><a id="l01147" name="l01147"></a><span class="lineno"> 1147</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01148" name="l01148"></a><span class="lineno"> 1148</span><span class="comment">   * Internal deleter functor used if and only if #S_IS_VANILLA_ALLOC is `false` and therefore only with</span></div>
<div class="line"><a id="l01149" name="l01149"></a><span class="lineno"> 1149</span><span class="comment">   * #Buf_ptr being `boost::interprocess::shared_ptr` or</span></div>
<div class="line"><a id="l01150" name="l01150"></a><span class="lineno"> 1150</span><span class="comment">   * deleter-parameterized `unique_ptr`.  Basically its task is to undo the</span></div>
<div class="line"><a id="l01151" name="l01151"></a><span class="lineno"> 1151</span><span class="comment">   * `m_alloc_raw.allocate()` call made when allocating a buffer in reserve(); the result of that call is</span></div>
<div class="line"><a id="l01152" name="l01152"></a><span class="lineno"> 1152</span><span class="comment">   * passed-to `shared_ptr::reset()` or `unique_ptr::reset()`; as is #m_alloc_raw (for any aux allocation needed,</span></div>
<div class="line"><a id="l01153" name="l01153"></a><span class="lineno"> 1153</span><span class="comment">   * but only for `shared_ptr` -- `unique_ptr` needs no aux data); as is</span></div>
<div class="line"><a id="l01154" name="l01154"></a><span class="lineno"> 1154</span><span class="comment">   * an instance of this Deleter_raw (to specifically dealloc the buffer when the ref-count reaches 0).</span></div>
<div class="line"><a id="l01155" name="l01155"></a><span class="lineno"> 1155</span><span class="comment">   * (In the `unique_ptr` case there is no ref-count per se; or one can think of it as a ref-count that equals 1.)</span></div>
<div class="line"><a id="l01156" name="l01156"></a><span class="lineno"> 1156</span><span class="comment">   *</span></div>
<div class="line"><a id="l01157" name="l01157"></a><span class="lineno"> 1157</span><span class="comment">   * Note that Deleter_raw is used only to dealloc the buffer actually controlled by the `shared_ptr` group</span></div>
<div class="line"><a id="l01158" name="l01158"></a><span class="lineno"> 1158</span><span class="comment">   * or `unique_ptr`.  `shared_ptr` will use the #Allocator_raw directly to dealloc aux data.  (We guess Deleter_raw</span></div>
<div class="line"><a id="l01159" name="l01159"></a><span class="lineno"> 1159</span><span class="comment">   * is a separate argument to `shared_ptr` to support array deletion; `boost::interprocess:shared_ptr` does not</span></div>
<div class="line"><a id="l01160" name="l01160"></a><span class="lineno"> 1160</span><span class="comment">   * provide built-in support for `U[]` as the pointee type; but the deleter can do whatever it wants/needs.)</span></div>
<div class="line"><a id="l01161" name="l01161"></a><span class="lineno"> 1161</span><span class="comment">   *</span></div>
<div class="line"><a id="l01162" name="l01162"></a><span class="lineno"> 1162</span><span class="comment">   * Note: this is not used except with custom #Allocator_raw.  With `std::allocator` the usual default `delete[]`</span></div>
<div class="line"><a id="l01163" name="l01163"></a><span class="lineno"> 1163</span><span class="comment">   * behavior is fine.</span></div>
<div class="line"><a id="l01164" name="l01164"></a><span class="lineno"> 1164</span><span class="comment">   */</span></div>
<div class="line"><a id="l01165" name="l01165"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html"> 1165</a></span>  <span class="keyword">class </span><a class="code hl_class" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html">Deleter_raw</a></div>
<div class="line"><a id="l01166" name="l01166"></a><span class="lineno"> 1166</span>  {</div>
<div class="line"><a id="l01167" name="l01167"></a><span class="lineno"> 1167</span>  <span class="keyword">public</span>:</div>
<div class="line"><a id="l01168" name="l01168"></a><span class="lineno"> 1168</span>    <span class="comment">// Types.</span></div>
<div class="line"><a id="l01169" name="l01169"></a><span class="lineno"> 1169</span><span class="comment"></span> </div>
<div class="line"><a id="l01170" name="l01170"></a><span class="lineno"> 1170</span><span class="comment">    /**</span></div>
<div class="line"><a id="l01171" name="l01171"></a><span class="lineno"> 1171</span><span class="comment">     * Short-hand for the allocator&#39;s pointer type, pointing to Basic_blob::value_type.</span></div>
<div class="line"><a id="l01172" name="l01172"></a><span class="lineno"> 1172</span><span class="comment">     * This may or may not simply be `value_type*`; in cases including SHM-storing allocators without</span></div>
<div class="line"><a id="l01173" name="l01173"></a><span class="lineno"> 1173</span><span class="comment">     * a constant cross-process vaddr scheme it needs to be a fancy-pointer type instead (e.g.,</span></div>
<div class="line"><a id="l01174" name="l01174"></a><span class="lineno"> 1174</span><span class="comment">     * `boost::interprocess::offset_ptr&lt;value_type&gt;`).</span></div>
<div class="line"><a id="l01175" name="l01175"></a><span class="lineno"> 1175</span><span class="comment">     */</span></div>
<div class="line"><a id="l01176" name="l01176"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#ad45a273758a0fc0bd81ab36edc9d8217"> 1176</a></span>    <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#ad45a273758a0fc0bd81ab36edc9d8217">Pointer_raw</a> = <span class="keyword">typename</span> std::allocator_traits&lt;Allocator_raw&gt;::pointer;</div>
<div class="line"><a id="l01177" name="l01177"></a><span class="lineno"> 1177</span><span class="comment"></span> </div>
<div class="line"><a id="l01178" name="l01178"></a><span class="lineno"> 1178</span><span class="comment">    /// For `boost::interprocess::shared_ptr` and `unique_ptr` compliance (hence the irregular capitalization).</span></div>
<div class="line"><a id="l01179" name="l01179"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a0152dc5043d6375124456f71d961988c"> 1179</a></span><span class="comment"></span>    <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a0152dc5043d6375124456f71d961988c">pointer</a> = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#ad45a273758a0fc0bd81ab36edc9d8217">Pointer_raw</a>;</div>
<div class="line"><a id="l01180" name="l01180"></a><span class="lineno"> 1180</span> </div>
<div class="line"><a id="l01181" name="l01181"></a><span class="lineno"> 1181</span>    <span class="comment">// Constructors/destructor.</span></div>
<div class="line"><a id="l01182" name="l01182"></a><span class="lineno"> 1182</span><span class="comment"></span> </div>
<div class="line"><a id="l01183" name="l01183"></a><span class="lineno"> 1183</span><span class="comment">    /**</span></div>
<div class="line"><a id="l01184" name="l01184"></a><span class="lineno"> 1184</span><span class="comment">     * Default ctor: Must never be invoked; suitable only for a null smart-pointer.</span></div>
<div class="line"><a id="l01185" name="l01185"></a><span class="lineno"> 1185</span><span class="comment">     * Without this a `unique_ptr&lt;..., Deleter_Raw&gt;` cannot be default-cted.</span></div>
<div class="line"><a id="l01186" name="l01186"></a><span class="lineno"> 1186</span><span class="comment">     */</span></div>
<div class="line"><a id="l01187" name="l01187"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a145ea5595e461bd93bd6e585a67516e6"> 1187</a></span>    <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a145ea5595e461bd93bd6e585a67516e6">Deleter_raw</a>();</div>
<div class="line"><a id="l01188" name="l01188"></a><span class="lineno"> 1188</span><span class="comment"></span> </div>
<div class="line"><a id="l01189" name="l01189"></a><span class="lineno"> 1189</span><span class="comment">    /**</span></div>
<div class="line"><a id="l01190" name="l01190"></a><span class="lineno"> 1190</span><span class="comment">     * Constructs deleter by memorizing the allocator (of zero size if #Allocator_raw is stateless, usually)</span></div>
<div class="line"><a id="l01191" name="l01191"></a><span class="lineno"> 1191</span><span class="comment">     * used to allocate whatever shall be passed-to `operator()()`; and the size (in # of `value_type`s)</span></div>
<div class="line"><a id="l01192" name="l01192"></a><span class="lineno"> 1192</span><span class="comment">     * of the buffer allocated there.  The latter is required, at least technically, because</span></div>
<div class="line"><a id="l01193" name="l01193"></a><span class="lineno"> 1193</span><span class="comment">     * `Allocator_raw::deallocate()` requires the value count, equal to that when `allocate()` was called,</span></div>
<div class="line"><a id="l01194" name="l01194"></a><span class="lineno"> 1194</span><span class="comment">     * to be passed-in.  Many allocators probably don&#39;t really need this, as array size is typically recorded</span></div>
<div class="line"><a id="l01195" name="l01195"></a><span class="lineno"> 1195</span><span class="comment">     * invisibly near the array itself, but formally this is not guaranteed for all allocators.</span></div>
<div class="line"><a id="l01196" name="l01196"></a><span class="lineno"> 1196</span><span class="comment">     *</span></div>
<div class="line"><a id="l01197" name="l01197"></a><span class="lineno"> 1197</span><span class="comment">     * @param alloc_raw</span></div>
<div class="line"><a id="l01198" name="l01198"></a><span class="lineno"> 1198</span><span class="comment">     *        Allocator to copy and store.</span></div>
<div class="line"><a id="l01199" name="l01199"></a><span class="lineno"> 1199</span><span class="comment">     * @param buf_sz</span></div>
<div class="line"><a id="l01200" name="l01200"></a><span class="lineno"> 1200</span><span class="comment">     *        See above.</span></div>
<div class="line"><a id="l01201" name="l01201"></a><span class="lineno"> 1201</span><span class="comment">     */</span></div>
<div class="line"><a id="l01202" name="l01202"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a40b06c7484a925fe7550a3437a0ad194"> 1202</a></span>    <span class="keyword">explicit</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a145ea5595e461bd93bd6e585a67516e6">Deleter_raw</a>(<span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a>&amp; alloc_raw, <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> buf_sz);</div>
<div class="line"><a id="l01203" name="l01203"></a><span class="lineno"> 1203</span> </div>
<div class="line"><a id="l01204" name="l01204"></a><span class="lineno"> 1204</span>    <span class="comment">// Methods.</span></div>
<div class="line"><a id="l01205" name="l01205"></a><span class="lineno"> 1205</span><span class="comment"></span> </div>
<div class="line"><a id="l01206" name="l01206"></a><span class="lineno"> 1206</span><span class="comment">    /**</span></div>
<div class="line"><a id="l01207" name="l01207"></a><span class="lineno"> 1207</span><span class="comment">     * Deallocates using `Allocator_raw::deallocate()`, passing-in the supplied pointer (to `value_type`) `to_delete`</span></div>
<div class="line"><a id="l01208" name="l01208"></a><span class="lineno"> 1208</span><span class="comment">     * and the number of `value_type`s to delete (from ctor).</span></div>
<div class="line"><a id="l01209" name="l01209"></a><span class="lineno"> 1209</span><span class="comment">     *</span></div>
<div class="line"><a id="l01210" name="l01210"></a><span class="lineno"> 1210</span><span class="comment">     * @param to_delete</span></div>
<div class="line"><a id="l01211" name="l01211"></a><span class="lineno"> 1211</span><span class="comment">     *        Pointer to buffer to delete as supplied by `shared_ptr` or `unique_ptr` internals.</span></div>
<div class="line"><a id="l01212" name="l01212"></a><span class="lineno"> 1212</span><span class="comment">     */</span></div>
<div class="line"><a id="l01213" name="l01213"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a83887b57f8a78c0224fd7563210e94ec"> 1213</a></span>    <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a83887b57f8a78c0224fd7563210e94ec">operator()</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#ad45a273758a0fc0bd81ab36edc9d8217">Pointer_raw</a> to_delete);</div>
<div class="line"><a id="l01214" name="l01214"></a><span class="lineno"> 1214</span> </div>
<div class="line"><a id="l01215" name="l01215"></a><span class="lineno"> 1215</span>  <span class="keyword">private</span>:</div>
<div class="line"><a id="l01216" name="l01216"></a><span class="lineno"> 1216</span>    <span class="comment">// Data.</span></div>
<div class="line"><a id="l01217" name="l01217"></a><span class="lineno"> 1217</span><span class="comment"></span> </div>
<div class="line"><a id="l01218" name="l01218"></a><span class="lineno"> 1218</span><span class="comment">    /**</span></div>
<div class="line"><a id="l01219" name="l01219"></a><span class="lineno"> 1219</span><span class="comment">     * See ctor: the allocator that `operator()()` shall use to deallocate.  For stateless allocators this</span></div>
<div class="line"><a id="l01220" name="l01220"></a><span class="lineno"> 1220</span><span class="comment">     * typically has size zero.</span></div>
<div class="line"><a id="l01221" name="l01221"></a><span class="lineno"> 1221</span><span class="comment">     *</span></div>
<div class="line"><a id="l01222" name="l01222"></a><span class="lineno"> 1222</span><span class="comment">     * ### What&#39;s with `optional&lt;&gt;`? ###</span></div>
<div class="line"><a id="l01223" name="l01223"></a><span class="lineno"> 1223</span><span class="comment">     * ...Okay, so actually this has size (whatever `optional` adds, probably a `bool`) + `sizeof(Allocator_raw)`,</span></div>
<div class="line"><a id="l01224" name="l01224"></a><span class="lineno"> 1224</span><span class="comment">     * the latter being indeed zero for stateless allocators.  Why use `optional&lt;&gt;` though?  Well, we only do</span></div>
<div class="line"><a id="l01225" name="l01225"></a><span class="lineno"> 1225</span><span class="comment">     * to support stateful allocators which cannot be default-cted; and our own default ctor requires that</span></div>
<div class="line"><a id="l01226" name="l01226"></a><span class="lineno"> 1226</span><span class="comment">     * #m_alloc_raw is initialized to *something*... even though it (by default ctor contract) will never be accessed.</span></div>
<div class="line"><a id="l01227" name="l01227"></a><span class="lineno"> 1227</span><span class="comment">     *</span></div>
<div class="line"><a id="l01228" name="l01228"></a><span class="lineno"> 1228</span><span class="comment">     * It is slightly annoying that we waste the extra space for `optional` internals even when `Allocator_raw`</span></div>
<div class="line"><a id="l01229" name="l01229"></a><span class="lineno"> 1229</span><span class="comment">     * is stateless (and it is often stateless!).  Plus, when #Buf_ptr is `shared_ptr` instead of `unique_ptr`</span></div>
<div class="line"><a id="l01230" name="l01230"></a><span class="lineno"> 1230</span><span class="comment">     * our default ctor is not even needed.  Probably some meta-programming thing could be done to avoid even this</span></div>
<div class="line"><a id="l01231" name="l01231"></a><span class="lineno"> 1231</span><span class="comment">     * overhead, but in my (ygoldfel) opinion the overhead is so minor, it does not even rise to the level of a to-do.</span></div>
<div class="line"><a id="l01232" name="l01232"></a><span class="lineno"> 1232</span><span class="comment">     */</span></div>
<div class="line"><a id="l01233" name="l01233"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a2b946cc7c51563ef74d1d47ebfad53c2"> 1233</a></span>    std::optional&lt;Allocator_raw&gt; <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a2b946cc7c51563ef74d1d47ebfad53c2">m_alloc_raw</a>;</div>
<div class="line"><a id="l01234" name="l01234"></a><span class="lineno"> 1234</span><span class="comment"></span> </div>
<div class="line"><a id="l01235" name="l01235"></a><span class="lineno"> 1235</span><span class="comment">    /// See ctor and operator()(): the size of the buffer to deallocate.</span></div>
<div class="line"><a id="l01236" name="l01236"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a2483f07aa6cf4ddb96309c4aa2eec00d"> 1236</a></span><span class="comment"></span>    <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a2483f07aa6cf4ddb96309c4aa2eec00d">m_buf_sz</a>;</div>
<div class="line"><a id="l01237" name="l01237"></a><span class="lineno"> 1237</span>  }; <span class="comment">// class Deleter_raw</span></div>
<div class="line"><a id="l01238" name="l01238"></a><span class="lineno"> 1238</span><span class="comment"></span> </div>
<div class="line"><a id="l01239" name="l01239"></a><span class="lineno"> 1239</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01240" name="l01240"></a><span class="lineno"> 1240</span><span class="comment">   * The smart-pointer type used for #m_buf_ptr; a custom-allocator-and-SHM-friendly impl and parameterization is</span></div>
<div class="line"><a id="l01241" name="l01241"></a><span class="lineno"> 1241</span><span class="comment">   * used if necessary; otherwise a more typical concrete type is used.</span></div>
<div class="line"><a id="l01242" name="l01242"></a><span class="lineno"> 1242</span><span class="comment">   *</span></div>
<div class="line"><a id="l01243" name="l01243"></a><span class="lineno"> 1243</span><span class="comment">   * The following discussion assumes the more complex case wherein #S_SHARING is `true`.  We discuss the simpler</span></div>
<div class="line"><a id="l01244" name="l01244"></a><span class="lineno"> 1244</span><span class="comment">   * converse case below that.</span></div>
<div class="line"><a id="l01245" name="l01245"></a><span class="lineno"> 1245</span><span class="comment">   *</span></div>
<div class="line"><a id="l01246" name="l01246"></a><span class="lineno"> 1246</span><span class="comment">   * Two things affect how #m_buf_ptr shall behave:</span></div>
<div class="line"><a id="l01247" name="l01247"></a><span class="lineno"> 1247</span><span class="comment">   *   - Which type this resolves-to depending on #S_IS_VANILLA_ALLOC (ultimately #Allocator_raw).  This affects</span></div>
<div class="line"><a id="l01248" name="l01248"></a><span class="lineno"> 1248</span><span class="comment">   *     many key things but most relevantly how it is dereferenced.  Namely:</span></div>
<div class="line"><a id="l01249" name="l01249"></a><span class="lineno"> 1249</span><span class="comment">   *     - Typical `shared_ptr` (used with vanilla allocator) will internally store simply a raw `value_type*`</span></div>
<div class="line"><a id="l01250" name="l01250"></a><span class="lineno"> 1250</span><span class="comment">   *       and dereference trivially.  This, however, will not work with some custom allocators, particularly</span></div>
<div class="line"><a id="l01251" name="l01251"></a><span class="lineno"> 1251</span><span class="comment">   *       SHM-heap ones (without a constant cross-process vaddr scheme), wherein a raw `T*` meaningful in</span></div>
<div class="line"><a id="l01252" name="l01252"></a><span class="lineno"> 1252</span><span class="comment">   *       the original process is meaningless in another.</span></div>
<div class="line"><a id="l01253" name="l01253"></a><span class="lineno"> 1253</span><span class="comment">   *       - `boost::shared_ptr` and `std::shared_ptr` both have custom-allocator support via</span></div>
<div class="line"><a id="l01254" name="l01254"></a><span class="lineno"> 1254</span><span class="comment">   *         `allocate_shared()` and co.  However, as of this writing, they are not SHM-friendly; or another</span></div>
<div class="line"><a id="l01255" name="l01255"></a><span class="lineno"> 1255</span><span class="comment">   *         way of putting it is they don&#39;t support custom allocators fully: `Allocator::pointer` is ignored;</span></div>
<div class="line"><a id="l01256" name="l01256"></a><span class="lineno"> 1256</span><span class="comment">   *         it is assumed to essentially be raw `value_type*`, in that the `shared_ptr` internally stores</span></div>
<div class="line"><a id="l01257" name="l01257"></a><span class="lineno"> 1257</span><span class="comment">   *         a raw pointer.  boost.interprocess refers to this as the impetus for implementing the following:</span></div>
<div class="line"><a id="l01258" name="l01258"></a><span class="lineno"> 1258</span><span class="comment">   *     - `boost::interprocess::shared_ptr` (used with custom allocator) will internally store an</span></div>
<div class="line"><a id="l01259" name="l01259"></a><span class="lineno"> 1259</span><span class="comment">   *       instance of `Allocator_raw::pointer` (to `value_type`) instead.  To dereference it, its operators</span></div>
<div class="line"><a id="l01260" name="l01260"></a><span class="lineno"> 1260</span><span class="comment">   *       such as `*` and `-&gt;` (etc.) will execute to properly translate to a raw `T*`.</span></div>
<div class="line"><a id="l01261" name="l01261"></a><span class="lineno"> 1261</span><span class="comment">   *       The aforementioned `pointer` may simply be `value_type*` again; in which case there is no difference</span></div>
<div class="line"><a id="l01262" name="l01262"></a><span class="lineno"> 1262</span><span class="comment">   *       to the standard `shared_ptr` situation; but it can instead be a fancy-pointer (actual technical term, yes,</span></div>
<div class="line"><a id="l01263" name="l01263"></a><span class="lineno"> 1263</span><span class="comment">   *       in cppreference.com et al), in which case some custom code will run to translate some internal</span></div>
<div class="line"><a id="l01264" name="l01264"></a><span class="lineno"> 1264</span><span class="comment">   *       data members (which have process-agnostic values) inside the fancy-pointer to a raw `T*`.</span></div>
<div class="line"><a id="l01265" name="l01265"></a><span class="lineno"> 1265</span><span class="comment">   *       For example `boost::interprocess::offset_ptr&lt;value_type&gt;` does this by adding a stored offset to its</span></div>
<div class="line"><a id="l01266" name="l01266"></a><span class="lineno"> 1266</span><span class="comment">   *       own `this`.</span></div>
<div class="line"><a id="l01267" name="l01267"></a><span class="lineno"> 1267</span><span class="comment">   *   - How it is reset to a newly allocated buffer in reserve() (when needed).</span></div>
<div class="line"><a id="l01268" name="l01268"></a><span class="lineno"> 1268</span><span class="comment">   *     - Typical `shared_ptr` is efficiently assigned using a `make_shared()` variant.  However, here we store</span></div>
<div class="line"><a id="l01269" name="l01269"></a><span class="lineno"> 1269</span><span class="comment">   *       a pointer to an array, not a single value (hence `&lt;value_type[]&gt;`); and we specifically want to avoid</span></div>
<div class="line"><a id="l01270" name="l01270"></a><span class="lineno"> 1270</span><span class="comment">   *       any 0-initialization of the elements (per one of Basic_blob&#39;s promises).  See reserve() which uses a</span></div>
<div class="line"><a id="l01271" name="l01271"></a><span class="lineno"> 1271</span><span class="comment">   *       `make_shared()` variant that accomplishes all this.</span></div>
<div class="line"><a id="l01272" name="l01272"></a><span class="lineno"> 1272</span><span class="comment">   *     - `boost::interprocess::shared_ptr` is reset differently due to a couple of restrictions, as it is made</span></div>
<div class="line"><a id="l01273" name="l01273"></a><span class="lineno"> 1273</span><span class="comment">   *       to be usable in SHM (SHared Memory), specifically, plus it seems to refrain from tacking on every</span></div>
<div class="line"><a id="l01274" name="l01274"></a><span class="lineno"> 1274</span><span class="comment">   *       normal `shared_ptr` feature.  To wit: 1, `virtual` cannot be used; therefore the deleter type must be</span></div>
<div class="line"><a id="l01275" name="l01275"></a><span class="lineno"> 1275</span><span class="comment">   *       declared at compile-time.  2, it has no special support for a native-array element-type (`value_type[]`).</span></div>
<div class="line"><a id="l01276" name="l01276"></a><span class="lineno"> 1276</span><span class="comment">   *       Therefore it leaves that part up to the user: the buffer must be pre-allocated by the user</span></div>
<div class="line"><a id="l01277" name="l01277"></a><span class="lineno"> 1277</span><span class="comment">   *       (and passed to `.reset()`); there is no `make_shared()` equivalent (which also means somewhat lower</span></div>
<div class="line"><a id="l01278" name="l01278"></a><span class="lineno"> 1278</span><span class="comment">   *       perf, as aux data and user buffer are separately allocated and stored).  Accordingly deletion is left</span></div>
<div class="line"><a id="l01279" name="l01279"></a><span class="lineno"> 1279</span><span class="comment">   *       to the user, as there is no default deleter; one must be supplied.  Thus:</span></div>
<div class="line"><a id="l01280" name="l01280"></a><span class="lineno"> 1280</span><span class="comment">   *       - See reserve(); it calls `.reset()` as explained here, including using #m_alloc_raw to pre-allocate.</span></div>
<div class="line"><a id="l01281" name="l01281"></a><span class="lineno"> 1281</span><span class="comment">   *       - See Deleter_raw, the deleter functor type an instance of which is saved by the `shared_ptr` to</span></div>
<div class="line"><a id="l01282" name="l01282"></a><span class="lineno"> 1282</span><span class="comment">   *         invoke when ref-count reaches 0.</span></div>
<div class="line"><a id="l01283" name="l01283"></a><span class="lineno"> 1283</span><span class="comment">   *</span></div>
<div class="line"><a id="l01284" name="l01284"></a><span class="lineno"> 1284</span><span class="comment">   * Other than that, it&#39;s a `shared_ptr`; it works as usual.</span></div>
<div class="line"><a id="l01285" name="l01285"></a><span class="lineno"> 1285</span><span class="comment">   *</span></div>
<div class="line"><a id="l01286" name="l01286"></a><span class="lineno"> 1286</span><span class="comment">   * ### Why use typical `shared_ptr` at all?  Won&#39;t the fancy-allocator-supporting one work for the vanilla case? ###</span></div>
<div class="line"><a id="l01287" name="l01287"></a><span class="lineno"> 1287</span><span class="comment">   * Yes, it would work.  And there would be less code without this dichotomy (although the differences are,</span></div>
<div class="line"><a id="l01288" name="l01288"></a><span class="lineno"> 1288</span><span class="comment">   * per above, local to this alias definition; and reserve() where it allocates buffer).  There are however reasons</span></div>
<div class="line"><a id="l01289" name="l01289"></a><span class="lineno"> 1289</span><span class="comment">   * why typical `shared_ptr` (we choose `boost::shared_ptr` over `std::shared_ptr`; that discussion is elsewhere,</span></div>
<div class="line"><a id="l01290" name="l01290"></a><span class="lineno"> 1290</span><span class="comment">   * but basically `boost::shared_ptr` is solid and full-featured/mature, though either choice would&#39;ve worked).</span></div>
<div class="line"><a id="l01291" name="l01291"></a><span class="lineno"> 1291</span><span class="comment">   * They are at least:</span></div>
<div class="line"><a id="l01292" name="l01292"></a><span class="lineno"> 1292</span><span class="comment">   *   - It is much more frequently used, preceding and anticipating its acceptance into the STL standard, so</span></div>
<div class="line"><a id="l01293" name="l01293"></a><span class="lineno"> 1293</span><span class="comment">   *     maturity and performance are likelier.</span></div>
<div class="line"><a id="l01294" name="l01294"></a><span class="lineno"> 1294</span><span class="comment">   *   - Specifically it supports a perf-enhancing use mode: using `make_shared()` (and similar) instead of</span></div>
<div class="line"><a id="l01295" name="l01295"></a><span class="lineno"> 1295</span><span class="comment">   *     `.reset(&lt;raw ptr&gt;)` (or similar ctor) replaces 2 allocs (1 for user data, 1 for aux data/ref-count)</span></div>
<div class="line"><a id="l01296" name="l01296"></a><span class="lineno"> 1296</span><span class="comment">   *     with 1 (for both).</span></div>
<div class="line"><a id="l01297" name="l01297"></a><span class="lineno"> 1297</span><span class="comment">   *   - If verbose logging in the deleter is desired, its `virtual`-based type-erased deleter semantics make that</span></div>
<div class="line"><a id="l01298" name="l01298"></a><span class="lineno"> 1298</span><span class="comment">   *     quite easy to achieve.</span></div>
<div class="line"><a id="l01299" name="l01299"></a><span class="lineno"> 1299</span><span class="comment">   *</span></div>
<div class="line"><a id="l01300" name="l01300"></a><span class="lineno"> 1300</span><span class="comment">   * ### The case where #S_SHARING is `false` ###</span></div>
<div class="line"><a id="l01301" name="l01301"></a><span class="lineno"> 1301</span><span class="comment">   * Firstly: if so then the method -- share() -- that would *ever* increment `Buf_ptr::use_count()` beyond 1</span></div>
<div class="line"><a id="l01302" name="l01302"></a><span class="lineno"> 1302</span><span class="comment">   * is simply not compiled.  Therefore using any type of `shared_ptr` is a waste of RAM (on the ref-count)</span></div>
<div class="line"><a id="l01303" name="l01303"></a><span class="lineno"> 1303</span><span class="comment">   * and cycles (on aux memory allocation and ref-count math), albeit a minor one.  Hence we use `unique_ptr`</span></div>
<div class="line"><a id="l01304" name="l01304"></a><span class="lineno"> 1304</span><span class="comment">   * in that case instead.  Even so, the above #S_IS_VANILLA_ALLOC dichotomy still applies but is quite a bit</span></div>
<div class="line"><a id="l01305" name="l01305"></a><span class="lineno"> 1305</span><span class="comment">   * simpler to handle; it&#39;s a degenerate case in a way.</span></div>
<div class="line"><a id="l01306" name="l01306"></a><span class="lineno"> 1306</span><span class="comment">   *   - Typical `unique_ptr` already stores `Deleter::pointer` instead of `value_ptr*`.  Therefore</span></div>
<div class="line"><a id="l01307" name="l01307"></a><span class="lineno"> 1307</span><span class="comment">   *     We can use it for both cases; in the vanilla case supplying no `Deleter` template param</span></div>
<div class="line"><a id="l01308" name="l01308"></a><span class="lineno"> 1308</span><span class="comment">   *     (the default `Deleter` has `pointer = value_ptr*`); otherwise supplying Deleter_raw whose</span></div>
<div class="line"><a id="l01309" name="l01309"></a><span class="lineno"> 1309</span><span class="comment">   *     Deleter_raw::pointer comes from `Allocator_raw::pointer`.  This also, same as with</span></div>
<div class="line"><a id="l01310" name="l01310"></a><span class="lineno"> 1310</span><span class="comment">   *     `boost::interprocess::shared_ptr`, takes care of the dealloc upon being nullified or destroyed.</span></div>
<div class="line"><a id="l01311" name="l01311"></a><span class="lineno"> 1311</span><span class="comment">   *   - As for initialization:</span></div>
<div class="line"><a id="l01312" name="l01312"></a><span class="lineno"> 1312</span><span class="comment">   *     - With #S_IS_VANILLA_ALLOC at `true`: Similarly to using a special array-friendly `make_shared()` variant,</span></div>
<div class="line"><a id="l01313" name="l01313"></a><span class="lineno"> 1313</span><span class="comment">   *       we use a special array-friendly `make_unique()` variant.</span></div>
<div class="line"><a id="l01314" name="l01314"></a><span class="lineno"> 1314</span><span class="comment">   *     - Otherwise: As with `boost::interprocess::shared_ptr` we cannot `make_*()` -- though AFAIK without</span></div>
<div class="line"><a id="l01315" name="l01315"></a><span class="lineno"> 1315</span><span class="comment">   *       any perf penalty (there is no aux data) -- but reserve() must be quite careful to also</span></div>
<div class="line"><a id="l01316" name="l01316"></a><span class="lineno"> 1316</span><span class="comment">   *       replace `m_buf_ptr`&#39;s deleter (which `.reset()` does not do... while `boost::interprocess::shared_ptr`</span></div>
<div class="line"><a id="l01317" name="l01317"></a><span class="lineno"> 1317</span><span class="comment">   *       does).</span></div>
<div class="line"><a id="l01318" name="l01318"></a><span class="lineno"> 1318</span><span class="comment">   */</span></div>
<div class="line"><a id="l01319" name="l01319"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a30fe0a61f8b83e7588bdc4a88dbaabae"> 1319</a></span>  <span class="keyword">using </span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a30fe0a61f8b83e7588bdc4a88dbaabae">Buf_ptr</a> = std::conditional_t&lt;<a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#ab79d366c55643022eaf9e0d7378165d7">S_IS_VANILLA_ALLOC</a>,</div>
<div class="line"><a id="l01320" name="l01320"></a><span class="lineno"> 1320</span>                                     std::conditional_t&lt;<a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#a67db182946127383fb48d6a1afbdca90">S_SHARING</a>,</div>
<div class="line"><a id="l01321" name="l01321"></a><span class="lineno"> 1321</span>                                                        boost::shared_ptr&lt;value_type[]&gt;,</div>
<div class="line"><a id="l01322" name="l01322"></a><span class="lineno"> 1322</span>                                                        boost::movelib::unique_ptr&lt;value_type[]&gt;&gt;,</div>
<div class="line"><a id="l01323" name="l01323"></a><span class="lineno"> 1323</span>                                     std::conditional_t&lt;<a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#a67db182946127383fb48d6a1afbdca90">S_SHARING</a>,</div>
<div class="line"><a id="l01324" name="l01324"></a><span class="lineno"> 1324</span>                                                        boost::interprocess::shared_ptr</div>
<div class="line"><a id="l01325" name="l01325"></a><span class="lineno"> 1325</span>                                                          &lt;<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>, <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a>, <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html">Deleter_raw</a>&gt;,</div>
<div class="line"><a id="l01326" name="l01326"></a><span class="lineno"> 1326</span>                                                        boost::movelib::unique_ptr&lt;value_type, Deleter_raw&gt;&gt;&gt;;</div>
<div class="line"><a id="l01327" name="l01327"></a><span class="lineno"> 1327</span> </div>
<div class="line"><a id="l01328" name="l01328"></a><span class="lineno"> 1328</span>  <span class="comment">// Methods.</span></div>
<div class="line"><a id="l01329" name="l01329"></a><span class="lineno"> 1329</span><span class="comment"></span> </div>
<div class="line"><a id="l01330" name="l01330"></a><span class="lineno"> 1330</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01331" name="l01331"></a><span class="lineno"> 1331</span><span class="comment">   * The body of swap(), except for the part that swaps (or decides not to swap) #m_alloc_raw.  As of this writing</span></div>
<div class="line"><a id="l01332" name="l01332"></a><span class="lineno"> 1332</span><span class="comment">   * used by swap() and assign() (move overload) which perform mutually different steps w/r/t #m_alloc_raw.</span></div>
<div class="line"><a id="l01333" name="l01333"></a><span class="lineno"> 1333</span><span class="comment">   *</span></div>
<div class="line"><a id="l01334" name="l01334"></a><span class="lineno"> 1334</span><span class="comment">   * @param other</span></div>
<div class="line"><a id="l01335" name="l01335"></a><span class="lineno"> 1335</span><span class="comment">   *        See swap().</span></div>
<div class="line"><a id="l01336" name="l01336"></a><span class="lineno"> 1336</span><span class="comment">   * @param logger_ptr</span></div>
<div class="line"><a id="l01337" name="l01337"></a><span class="lineno"> 1337</span><span class="comment">   *        See swap().</span></div>
<div class="line"><a id="l01338" name="l01338"></a><span class="lineno"> 1338</span><span class="comment">   */</span></div>
<div class="line"><a id="l01339" name="l01339"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#adc0bb760b5f2f36147d128e2e5fbe95f"> 1339</a></span>  <span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#adc0bb760b5f2f36147d128e2e5fbe95f">swap_impl</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; other, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr);</div>
<div class="line"><a id="l01340" name="l01340"></a><span class="lineno"> 1340</span><span class="comment"></span> </div>
<div class="line"><a id="l01341" name="l01341"></a><span class="lineno"> 1341</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01342" name="l01342"></a><span class="lineno"> 1342</span><span class="comment">   * Returns iterator-to-mutable equivalent to given iterator-to-immutable.</span></div>
<div class="line"><a id="l01343" name="l01343"></a><span class="lineno"> 1343</span><span class="comment">   *</span></div>
<div class="line"><a id="l01344" name="l01344"></a><span class="lineno"> 1344</span><span class="comment">   * @param it</span></div>
<div class="line"><a id="l01345" name="l01345"></a><span class="lineno"> 1345</span><span class="comment">   *        Self-explanatory.  No assumptions are made about valid_iterator() or derefable_iterator() status.</span></div>
<div class="line"><a id="l01346" name="l01346"></a><span class="lineno"> 1346</span><span class="comment">   * @return Iterator to same location as `it`.</span></div>
<div class="line"><a id="l01347" name="l01347"></a><span class="lineno"> 1347</span><span class="comment">   */</span></div>
<div class="line"><a id="l01348" name="l01348"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a9c8a51530bc17f779215970f3097a1f2"> 1348</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9c8a51530bc17f779215970f3097a1f2">iterator_sans_const</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> it);</div>
<div class="line"><a id="l01349" name="l01349"></a><span class="lineno"> 1349</span> </div>
<div class="line"><a id="l01350" name="l01350"></a><span class="lineno"> 1350</span>  <span class="comment">// Data.</span></div>
<div class="line"><a id="l01351" name="l01351"></a><span class="lineno"> 1351</span><span class="comment"></span> </div>
<div class="line"><a id="l01352" name="l01352"></a><span class="lineno"> 1352</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01353" name="l01353"></a><span class="lineno"> 1353</span><span class="comment">   * See get_allocator(): copy of the allocator supplied by the user (though, if #Allocator_raw is stateless,</span></div>
<div class="line"><a id="l01354" name="l01354"></a><span class="lineno"> 1354</span><span class="comment">   * it is typically defaulted to `Allocator_raw()`), as set by a constructor or assign() or</span></div>
<div class="line"><a id="l01355" name="l01355"></a><span class="lineno"> 1355</span><span class="comment">   * assignment-operator, whichever happened last.  Used exclusively when allocating and deallocating</span></div>
<div class="line"><a id="l01356" name="l01356"></a><span class="lineno"> 1356</span><span class="comment">   * #m_buf_ptr in the *next* reserve() (potentially).</span></div>
<div class="line"><a id="l01357" name="l01357"></a><span class="lineno"> 1357</span><span class="comment">   *</span></div>
<div class="line"><a id="l01358" name="l01358"></a><span class="lineno"> 1358</span><span class="comment">   * By the rules of `Allocator_aware_container` (see cppreference.com):</span></div>
<div class="line"><a id="l01359" name="l01359"></a><span class="lineno"> 1359</span><span class="comment">   *   - If `*this` is move-cted: member move-cted from source member counterpart.</span></div>
<div class="line"><a id="l01360" name="l01360"></a><span class="lineno"> 1360</span><span class="comment">   *   - If `*this` is move-assigned: member move-assigned from source member counterpart if</span></div>
<div class="line"><a id="l01361" name="l01361"></a><span class="lineno"> 1361</span><span class="comment">   *     `std::allocator_traits&lt;Allocator_raw&gt;::propagate_on_container_move_assignment::value == true` (else untouched).</span></div>
<div class="line"><a id="l01362" name="l01362"></a><span class="lineno"> 1362</span><span class="comment">   *   - If `*this` is copy-cted: member set to</span></div>
<div class="line"><a id="l01363" name="l01363"></a><span class="lineno"> 1363</span><span class="comment">   *     `std::allocator_traits&lt;Allocator_raw&gt;::select_on_container_copy_construction()` (pass-in source member</span></div>
<div class="line"><a id="l01364" name="l01364"></a><span class="lineno"> 1364</span><span class="comment">   *     counterpart).</span></div>
<div class="line"><a id="l01365" name="l01365"></a><span class="lineno"> 1365</span><span class="comment">   *   - If `*this` is copy-assigned: member copy-assigned if</span></div>
<div class="line"><a id="l01366" name="l01366"></a><span class="lineno"> 1366</span><span class="comment">   *     `std::allocator_traits&lt;Allocator_raw&gt;::propagate_on_container_copy_assignment::value == true` (else untouched).</span></div>
<div class="line"><a id="l01367" name="l01367"></a><span class="lineno"> 1367</span><span class="comment">   *   - If `*this` is `swap()`ed: member ADL-`swap()`ed with source member counterpart if</span></div>
<div class="line"><a id="l01368" name="l01368"></a><span class="lineno"> 1368</span><span class="comment">   *     `std::allocator_traits&lt;Allocator_raw&gt;::propagate_on_container_swap::value == true` (else untouched).</span></div>
<div class="line"><a id="l01369" name="l01369"></a><span class="lineno"> 1369</span><span class="comment">   *   - Otherwise this is supplied via a non-copy/move ctor arg by user.</span></div>
<div class="line"><a id="l01370" name="l01370"></a><span class="lineno"> 1370</span><span class="comment">   *</span></div>
<div class="line"><a id="l01371" name="l01371"></a><span class="lineno"> 1371</span><span class="comment">   * ### Specially treated value ###</span></div>
<div class="line"><a id="l01372" name="l01372"></a><span class="lineno"> 1372</span><span class="comment">   * If #Allocator_raw is `std::allocator&lt;value_type&gt;` (as supposed to `something_else&lt;value_type&gt;`), then</span></div>
<div class="line"><a id="l01373" name="l01373"></a><span class="lineno"> 1373</span><span class="comment">   * #m_alloc_raw (while guaranteed set to the zero-sized copy of `std::allocator&lt;value_type&gt;()`) is never</span></div>
<div class="line"><a id="l01374" name="l01374"></a><span class="lineno"> 1374</span><span class="comment">   * in practice touched (outside of the above-mentioned moves/copies/swaps, though they also do nothing in reality</span></div>
<div class="line"><a id="l01375" name="l01375"></a><span class="lineno"> 1375</span><span class="comment">   * for this stateless allocator).  This value by definition means we are to allocate on the regular heap;</span></div>
<div class="line"><a id="l01376" name="l01376"></a><span class="lineno"> 1376</span><span class="comment">   * and as of this writing for perf/other reasons we choose to use a vanilla</span></div>
<div class="line"><a id="l01377" name="l01377"></a><span class="lineno"> 1377</span><span class="comment">   * `*_ptr` with its default alloc-dealloc APIs (which perform `new[]`-`delete[]` respectively); we do not pass-in</span></div>
<div class="line"><a id="l01378" name="l01378"></a><span class="lineno"> 1378</span><span class="comment">   * #m_alloc_raw anywhere.  See #Buf_ptr doc header for more.  If we did pass it in to</span></div>
<div class="line"><a id="l01379" name="l01379"></a><span class="lineno"> 1379</span><span class="comment">   * `allocate_shared*()` or `boost::interprocess::shared_ptr::reset` the end result would be functionally</span></div>
<div class="line"><a id="l01380" name="l01380"></a><span class="lineno"> 1380</span><span class="comment">   * the same (`std::allocator::[de]allocate()` would get called; these call `new[]`/`delete[]`).</span></div>
<div class="line"><a id="l01381" name="l01381"></a><span class="lineno"> 1381</span><span class="comment">   *</span></div>
<div class="line"><a id="l01382" name="l01382"></a><span class="lineno"> 1382</span><span class="comment">   * ### Relationship between #m_alloc_raw and the allocator/deleter in #m_buf_ptr ###</span></div>
<div class="line"><a id="l01383" name="l01383"></a><span class="lineno"> 1383</span><span class="comment">   * (This is only applicable if #S_IS_VANILLA_ALLOC is `false`.)</span></div>
<div class="line"><a id="l01384" name="l01384"></a><span class="lineno"> 1384</span><span class="comment">   * #m_buf_ptr caches #m_alloc_raw internally in its centrally linked data.  Ordinarily, then, they compare as equal.</span></div>
<div class="line"><a id="l01385" name="l01385"></a><span class="lineno"> 1385</span><span class="comment">   * In the corner case where (1) move-assign or copy-assign or swap() was used on `*this`, *and*</span></div>
<div class="line"><a id="l01386" name="l01386"></a><span class="lineno"> 1386</span><span class="comment">   * (2) #Allocator_raw is stateful and *can* compare unequal (e.g., `boost::interprocess::allocator`):</span></div>
<div class="line"><a id="l01387" name="l01387"></a><span class="lineno"> 1387</span><span class="comment">   * they may come to compare as unequal.  It is, however, not (in our case) particularly important:</span></div>
<div class="line"><a id="l01388" name="l01388"></a><span class="lineno"> 1388</span><span class="comment">   * #m_alloc_raw affects the *next* reserve() (potentially); the thing stored in #m_buf_ptr affects the logic when</span></div>
<div class="line"><a id="l01389" name="l01389"></a><span class="lineno"> 1389</span><span class="comment">   * the underlying buffer is next deallocated.  The two don&#39;t depend on each other.</span></div>
<div class="line"><a id="l01390" name="l01390"></a><span class="lineno"> 1390</span><span class="comment">   */</span></div>
<div class="line"><a id="l01391" name="l01391"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ac7478166f4244b068a8793dc90b1f9e4"> 1391</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a> <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#ac7478166f4244b068a8793dc90b1f9e4">m_alloc_raw</a>;</div>
<div class="line"><a id="l01392" name="l01392"></a><span class="lineno"> 1392</span><span class="comment"></span> </div>
<div class="line"><a id="l01393" name="l01393"></a><span class="lineno"> 1393</span><span class="comment">  /**</span></div>
<div class="line"><a id="l01394" name="l01394"></a><span class="lineno"> 1394</span><span class="comment">   * Pointer to currently allocated buffer of size #m_capacity; null if and only if `zero() == true`.</span></div>
<div class="line"><a id="l01395" name="l01395"></a><span class="lineno"> 1395</span><span class="comment">   * Buffer is auto-freed at destruction; or in make_zero(); but only if by that point any share()-generated</span></div>
<div class="line"><a id="l01396" name="l01396"></a><span class="lineno"> 1396</span><span class="comment">   * other `Basic_blob`s have done the same.  Otherwise the ref-count is merely decremented.</span></div>
<div class="line"><a id="l01397" name="l01397"></a><span class="lineno"> 1397</span><span class="comment">   * In the case of #S_SHARING being `false`, one can think of this ref-count as being always at most 1;</span></div>
<div class="line"><a id="l01398" name="l01398"></a><span class="lineno"> 1398</span><span class="comment">   * since share() is not compiled, and as a corollary a `unique_ptr` is used to avoid perf costs.</span></div>
<div class="line"><a id="l01399" name="l01399"></a><span class="lineno"> 1399</span><span class="comment">   * Thus make_zero() and dtor always dealloc in that case.</span></div>
<div class="line"><a id="l01400" name="l01400"></a><span class="lineno"> 1400</span><span class="comment">   *</span></div>
<div class="line"><a id="l01401" name="l01401"></a><span class="lineno"> 1401</span><span class="comment">   * For performance, we never initialize the values in the array to zeroes or otherwise.</span></div>
<div class="line"><a id="l01402" name="l01402"></a><span class="lineno"> 1402</span><span class="comment">   * This contrasts with `vector` and most other standard or Boost containers which use an `allocator` to</span></div>
<div class="line"><a id="l01403" name="l01403"></a><span class="lineno"> 1403</span><span class="comment">   * allocate any internal buffer, and most allocators default-construct (which means assign 0 in case of `uint8_t`)</span></div>
<div class="line"><a id="l01404" name="l01404"></a><span class="lineno"> 1404</span><span class="comment">   * any elements within allocated buffers, immediately upon the actual allocation on heap.  As noted in doc header,</span></div>
<div class="line"><a id="l01405" name="l01405"></a><span class="lineno"> 1405</span><span class="comment">   * this behavior is surprisingly difficult to avoid (involving custom allocators and such).</span></div>
<div class="line"><a id="l01406" name="l01406"></a><span class="lineno"> 1406</span><span class="comment">   */</span></div>
<div class="line"><a id="l01407" name="l01407"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a45b5f98e106d0cd36956063cd859d3c6"> 1407</a></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a30fe0a61f8b83e7588bdc4a88dbaabae">Buf_ptr</a> <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#a45b5f98e106d0cd36956063cd859d3c6">m_buf_ptr</a>;</div>
<div class="line"><a id="l01408" name="l01408"></a><span class="lineno"> 1408</span><span class="comment"></span> </div>
<div class="line"><a id="l01409" name="l01409"></a><span class="lineno"> 1409</span><span class="comment">  /// See capacity(); but #m_capacity is meaningless (and containing unknown value) if `!m_buf_ptr` (i.e., zero()).</span></div>
<div class="line"><a id="l01410" name="l01410"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a1f2d99a5b487a454af627e8e33738abf"> 1410</a></span><span class="comment"></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#a1f2d99a5b487a454af627e8e33738abf">m_capacity</a>;</div>
<div class="line"><a id="l01411" name="l01411"></a><span class="lineno"> 1411</span><span class="comment"></span> </div>
<div class="line"><a id="l01412" name="l01412"></a><span class="lineno"> 1412</span><span class="comment">  /// See start(); but #m_start is meaningless (and containing unknown value) if `!m_buf_ptr` (i.e., zero()).</span></div>
<div class="line"><a id="l01413" name="l01413"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aae53d36a27090ef5da931bc17d4f2bcd"> 1413</a></span><span class="comment"></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#aae53d36a27090ef5da931bc17d4f2bcd">m_start</a>;</div>
<div class="line"><a id="l01414" name="l01414"></a><span class="lineno"> 1414</span><span class="comment"></span> </div>
<div class="line"><a id="l01415" name="l01415"></a><span class="lineno"> 1415</span><span class="comment">  /// See size(); but #m_size is meaningless (and containing unknown value) if `!m_buf_ptr` (i.e., zero()).</span></div>
<div class="line"><a id="l01416" name="l01416"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ac008b60f7fe4253be9527436b0661dcc"> 1416</a></span><span class="comment"></span>  <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#ac008b60f7fe4253be9527436b0661dcc">m_size</a>;</div>
<div class="line"><a id="l01417" name="l01417"></a><span class="lineno"> 1417</span>}; <span class="comment">// class Basic_blob</span></div>
<div class="line"><a id="l01418" name="l01418"></a><span class="lineno"> 1418</span> </div>
<div class="line"><a id="l01419" name="l01419"></a><span class="lineno"> 1419</span><span class="comment">// Free functions: in *_fwd.hpp.</span></div>
<div class="line"><a id="l01420" name="l01420"></a><span class="lineno"> 1420</span> </div>
<div class="line"><a id="l01421" name="l01421"></a><span class="lineno"> 1421</span><span class="comment">// Template implementations.</span></div>
<div class="line"><a id="l01422" name="l01422"></a><span class="lineno"> 1422</span> </div>
<div class="line"><a id="l01423" name="l01423"></a><span class="lineno"> 1423</span><span class="comment">// m_buf_ptr initialized to null pointer.  n_capacity and m_size remain uninit (meaningless until m_buf_ptr changes).</span></div>
<div class="line"><a id="l01424" name="l01424"></a><span class="lineno"> 1424</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01425" name="l01425"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#abbd8243321a70378f27b551ff8082619"> 1425</a></span><a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#abbd8243321a70378f27b551ff8082619">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Basic_blob</a>(<span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a>&amp; alloc_raw) :</div>
<div class="line"><a id="l01426" name="l01426"></a><span class="lineno"> 1426</span>  m_alloc_raw(alloc_raw) <span class="comment">// Copy allocator; stateless allocator should have size 0 (no-op for the processor).</span></div>
<div class="line"><a id="l01427" name="l01427"></a><span class="lineno"> 1427</span>{</div>
<div class="line"><a id="l01428" name="l01428"></a><span class="lineno"> 1428</span>  <span class="comment">// OK.</span></div>
<div class="line"><a id="l01429" name="l01429"></a><span class="lineno"> 1429</span>}</div>
<div class="line"><a id="l01430" name="l01430"></a><span class="lineno"> 1430</span> </div>
<div class="line"><a id="l01431" name="l01431"></a><span class="lineno"> 1431</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01432" name="l01432"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a625734b39e0e3317aa321b6f8569f334"> 1432</a></span><a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#abbd8243321a70378f27b551ff8082619">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Basic_blob</a></div>
<div class="line"><a id="l01433" name="l01433"></a><span class="lineno"> 1433</span>  (<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> size, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr, <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a>&amp; alloc_raw) :</div>
<div class="line"><a id="l01434" name="l01434"></a><span class="lineno"> 1434</span> </div>
<div class="line"><a id="l01435" name="l01435"></a><span class="lineno"> 1435</span>  <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>(alloc_raw) <span class="comment">// Delegate.</span></div>
<div class="line"><a id="l01436" name="l01436"></a><span class="lineno"> 1436</span>{</div>
<div class="line"><a id="l01437" name="l01437"></a><span class="lineno"> 1437</span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a30b8db540e6d8e6a0b6200c17cf45b60">resize</a>(<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">size</a>, 0, logger_ptr);</div>
<div class="line"><a id="l01438" name="l01438"></a><span class="lineno"> 1438</span>}</div>
<div class="line"><a id="l01439" name="l01439"></a><span class="lineno"> 1439</span> </div>
<div class="line"><a id="l01440" name="l01440"></a><span class="lineno"> 1440</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01441" name="l01441"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a3568f40cab930beabf5bd831489d610a"> 1441</a></span><a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#abbd8243321a70378f27b551ff8082619">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Basic_blob</a>(<span class="keyword">const</span> <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; src, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr) :</div>
<div class="line"><a id="l01442" name="l01442"></a><span class="lineno"> 1442</span>  <span class="comment">// Follow rules established in m_alloc_raw doc header:</span></div>
<div class="line"><a id="l01443" name="l01443"></a><span class="lineno"> 1443</span>  m_alloc_raw(std::allocator_traits&lt;<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a>&gt;::select_on_container_copy_construction(src.m_alloc_raw))</div>
<div class="line"><a id="l01444" name="l01444"></a><span class="lineno"> 1444</span>{</div>
<div class="line"><a id="l01445" name="l01445"></a><span class="lineno"> 1445</span>  <span class="comment">/* What we want to do here, ignoring allocators, is (for concision): `assign(src, logger_ptr);`</span></div>
<div class="line"><a id="l01446" name="l01446"></a><span class="lineno"> 1446</span><span class="comment">   * However copy-assignment also must do something different w/r/t m_alloc_raw than what we had to do above</span></div>
<div class="line"><a id="l01447" name="l01447"></a><span class="lineno"> 1447</span><span class="comment">   * (again see m_alloc_raw doc header); so just copy/paste the rest of what operator=(copy) would do.</span></div>
<div class="line"><a id="l01448" name="l01448"></a><span class="lineno"> 1448</span><span class="comment">   * Skipping most comments therein, as they don&#39;t much apply in our case.  Code reuse level is all-right;</span></div>
<div class="line"><a id="l01449" name="l01449"></a><span class="lineno"> 1449</span><span class="comment">   * and we can skip the `if` from assign(). */</span></div>
<div class="line"><a id="l01450" name="l01450"></a><span class="lineno"> 1450</span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a4939ea2f0c76ec448cdc12275ce17f33">assign_copy</a>(src.<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#afbb4e2420be2f8ca0dc8c4fb70feb8ea">const_buffer</a>(), logger_ptr);</div>
<div class="line"><a id="l01451" name="l01451"></a><span class="lineno"> 1451</span>}</div>
<div class="line"><a id="l01452" name="l01452"></a><span class="lineno"> 1452</span> </div>
<div class="line"><a id="l01453" name="l01453"></a><span class="lineno"> 1453</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01454" name="l01454"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a477ff0db26f79989d75da4dbe4bf4982"> 1454</a></span><a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#abbd8243321a70378f27b551ff8082619">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Basic_blob</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp;&amp; moved_src, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr) :</div>
<div class="line"><a id="l01455" name="l01455"></a><span class="lineno"> 1455</span>  <span class="comment">// Follow rules established in m_alloc_raw doc header:</span></div>
<div class="line"><a id="l01456" name="l01456"></a><span class="lineno"> 1456</span>  m_alloc_raw(std::move(moved_src.m_alloc_raw))</div>
<div class="line"><a id="l01457" name="l01457"></a><span class="lineno"> 1457</span>{</div>
<div class="line"><a id="l01458" name="l01458"></a><span class="lineno"> 1458</span>  <span class="comment">/* Similar to copy ctor above, do the equivalent of assign(move(moved_src), logger_ptr) minus the allocator work.</span></div>
<div class="line"><a id="l01459" name="l01459"></a><span class="lineno"> 1459</span><span class="comment">   * That reduces to simply: */</span></div>
<div class="line"><a id="l01460" name="l01460"></a><span class="lineno"> 1460</span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#adc0bb760b5f2f36147d128e2e5fbe95f">swap_impl</a>(moved_src, logger_ptr);</div>
<div class="line"><a id="l01461" name="l01461"></a><span class="lineno"> 1461</span>}</div>
<div class="line"><a id="l01462" name="l01462"></a><span class="lineno"> 1462</span> </div>
<div class="line"><a id="l01463" name="l01463"></a><span class="lineno"> 1463</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01464" name="l01464"></a><span class="lineno"> 1464</span><a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ae9fc395523fae83128888d9bb1c90726">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::~Basic_blob</a>() = <span class="keywordflow">default</span>;</div>
<div class="line"><a id="l01465" name="l01465"></a><span class="lineno"> 1465</span> </div>
<div class="line"><a id="l01466" name="l01466"></a><span class="lineno"> 1466</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01467" name="l01467"></a><span class="lineno"> 1467</span><a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a>&amp;</div>
<div class="line"><a id="l01468" name="l01468"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aff44a959c238ea8aae3230c0b834d558"> 1468</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a77785988abe56d62dacf42ec6a733713">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::assign</a>(<span class="keyword">const</span> <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; src, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01469" name="l01469"></a><span class="lineno"> 1469</span>{</div>
<div class="line"><a id="l01470" name="l01470"></a><span class="lineno"> 1470</span>  <span class="keywordflow">if</span> (<span class="keyword">this</span> != &amp;src)</div>
<div class="line"><a id="l01471" name="l01471"></a><span class="lineno"> 1471</span>  {</div>
<div class="line"><a id="l01472" name="l01472"></a><span class="lineno"> 1472</span>    <span class="comment">// Take care of the &quot;Sharing blobs&quot; corner case from our doc header.  The rationale for this is pointed out there.</span></div>
<div class="line"><a id="l01473" name="l01473"></a><span class="lineno"> 1473</span>    <span class="keywordflow">if</span> <span class="keyword">constexpr</span>(S_SHARING)</div>
<div class="line"><a id="l01474" name="l01474"></a><span class="lineno"> 1474</span>    {</div>
<div class="line"><a id="l01475" name="l01475"></a><span class="lineno"> 1475</span>      assert(!<a class="code hl_function" href="namespaceflow_1_1util.html#af567381736851969f6e8812c54404028">blobs_sharing</a>(*<span class="keyword">this</span>, src));</div>
<div class="line"><a id="l01476" name="l01476"></a><span class="lineno"> 1476</span>    }</div>
<div class="line"><a id="l01477" name="l01477"></a><span class="lineno"> 1477</span> </div>
<div class="line"><a id="l01478" name="l01478"></a><span class="lineno"> 1478</span>    <span class="comment">// For m_alloc_raw: Follow rules established in m_alloc_raw doc header.</span></div>
<div class="line"><a id="l01479" name="l01479"></a><span class="lineno"> 1479</span>    <span class="keywordflow">if</span> <span class="keyword">constexpr</span>(std::allocator_traits&lt;Allocator_raw&gt;::propagate_on_container_copy_assignment::value)</div>
<div class="line"><a id="l01480" name="l01480"></a><span class="lineno"> 1480</span>    {</div>
<div class="line"><a id="l01481" name="l01481"></a><span class="lineno"> 1481</span>      m_alloc_raw = src.<a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#ac7478166f4244b068a8793dc90b1f9e4">m_alloc_raw</a>;</div>
<div class="line"><a id="l01482" name="l01482"></a><span class="lineno"> 1482</span>      <span class="comment">/* Let&#39;s consider what just happened.  Allocator_raw&#39;s policy is to, yes, copy m_alloc_raw from</span></div>
<div class="line"><a id="l01483" name="l01483"></a><span class="lineno"> 1483</span><span class="comment">       * src to *this; so we did.  Now suppose !zero() and !src.zero(); and that old m_alloc_raw != src.m_alloc_raw.</span></div>
<div class="line"><a id="l01484" name="l01484"></a><span class="lineno"> 1484</span><span class="comment">       * (E.g., boost::interprocess::allocator&lt;&gt;s with same type but set to different SHM segments S1 and S2 would</span></div>
<div class="line"><a id="l01485" name="l01485"></a><span class="lineno"> 1485</span><span class="comment">       * compare unequal.)  What needs to happen is *m_buf_ptr buffer must be freed (more accurately, its</span></div>
<div class="line"><a id="l01486" name="l01486"></a><span class="lineno"> 1486</span><span class="comment">       * shared_ptr ref_count decremented and thus buffer possibly freed if not share()d); then allocated; then</span></div>
<div class="line"><a id="l01487" name="l01487"></a><span class="lineno"> 1487</span><span class="comment">       * contents linear-copied from *src.m_buf_ptr buffer to *m_buf_ptr buffer.  assign_copy() below naively</span></div>
<div class="line"><a id="l01488" name="l01488"></a><span class="lineno"> 1488</span><span class="comment">       * does all that; but will it work since we&#39;ve thrown away the old m_alloc_raw?  Let&#39;s go through it:</span></div>
<div class="line"><a id="l01489" name="l01489"></a><span class="lineno"> 1489</span><span class="comment">       *   -# Basically m_buf_ptr.reset(&lt;new buffer ptr&gt;) is kinda like m_buf_ptr.reset() followed by</span></div>
<div class="line"><a id="l01490" name="l01490"></a><span class="lineno"> 1490</span><span class="comment">       *      m_buf_ptr.reset(&lt;new buffer ptr&gt;); the former part is the possible-dealloc.  So will it work?</span></div>
<div class="line"><a id="l01491" name="l01491"></a><span class="lineno"> 1491</span><span class="comment">       *      Yes: shared_ptr&lt;&gt; stores the buffer and aux data (ref-count, allocator, deleter) in one central</span></div>
<div class="line"><a id="l01492" name="l01492"></a><span class="lineno"> 1492</span><span class="comment">       *      place shared with other shared_ptr&lt;&gt;s in its group.  The .reset() dec-refs the ref-count and dissociates</span></div>
<div class="line"><a id="l01493" name="l01493"></a><span class="lineno"> 1493</span><span class="comment">       *      m_buf_ptr from the central place; if the ref-count is 0, then it also deallocs the buffer and the</span></div>
<div class="line"><a id="l01494" name="l01494"></a><span class="lineno"> 1494</span><span class="comment">       *      aux data and eliminates the central place... using the allocator/deleter cached in that central</span></div>
<div class="line"><a id="l01495" name="l01495"></a><span class="lineno"> 1495</span><span class="comment">       *      place itself.  Hence the old m_alloc_raw&#39;s copy will go in effect when the nullifying .reset() part</span></div>
<div class="line"><a id="l01496" name="l01496"></a><span class="lineno"> 1496</span><span class="comment">       *      happens.</span></div>
<div class="line"><a id="l01497" name="l01497"></a><span class="lineno"> 1497</span><span class="comment">       *   -# So then m_buf_ptr is .reset() to the newly allocated buffer which will be allocated by us explicitly</span></div>
<div class="line"><a id="l01498" name="l01498"></a><span class="lineno"> 1498</span><span class="comment">       *      using m_alloc_raw (which we&#39;ve replaced just now).</span></div>
<div class="line"><a id="l01499" name="l01499"></a><span class="lineno"> 1499</span><span class="comment">       *   -# Then the linear copy in assign_copy() is uncontroversial; everything is allocated before this starts. */</span></div>
<div class="line"><a id="l01500" name="l01500"></a><span class="lineno"> 1500</span>    }</div>
<div class="line"><a id="l01501" name="l01501"></a><span class="lineno"> 1501</span>    <span class="comment">/* else: Leave m_alloc_raw alone.  Everything should be fine once we assign_copy() below: existing m_buf_ptr</span></div>
<div class="line"><a id="l01502" name="l01502"></a><span class="lineno"> 1502</span><span class="comment">     * (if not null) will dealloc without any allocator-related disruption/change; then it&#39;ll be reset to a new buffer</span></div>
<div class="line"><a id="l01503" name="l01503"></a><span class="lineno"> 1503</span><span class="comment">     * with contents linear-copied over.  The unchanged m_alloc_raw will be used for the *next* allocating reserve()</span></div>
<div class="line"><a id="l01504" name="l01504"></a><span class="lineno"> 1504</span><span class="comment">     * if any. */</span></div>
<div class="line"><a id="l01505" name="l01505"></a><span class="lineno"> 1505</span> </div>
<div class="line"><a id="l01506" name="l01506"></a><span class="lineno"> 1506</span>    <span class="comment">// Now to the relatively uncontroversial stuff.  To copy the rest we&#39;ll just do:</span></div>
<div class="line"><a id="l01507" name="l01507"></a><span class="lineno"> 1507</span> </div>
<div class="line"><a id="l01508" name="l01508"></a><span class="lineno"> 1508</span>    <span class="comment">/* resize(N, 0); copy over N bytes.  Note that it disallows `N &gt; capacity()` unless zero(), but they can explicitly</span></div>
<div class="line"><a id="l01509" name="l01509"></a><span class="lineno"> 1509</span><span class="comment">     * make_zero() before calling us, if they are explicitly OK with the performance cost of the reallocation that will</span></div>
<div class="line"><a id="l01510" name="l01510"></a><span class="lineno"> 1510</span><span class="comment">     * trigger.  This is all as advertised; and it satisfies the top priority listed just below. */</span></div>
<div class="line"><a id="l01511" name="l01511"></a><span class="lineno"> 1511</span>    assign_copy(src.<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#afbb4e2420be2f8ca0dc8c4fb70feb8ea">const_buffer</a>(), logger_ptr);</div>
<div class="line"><a id="l01512" name="l01512"></a><span class="lineno"> 1512</span> </div>
<div class="line"><a id="l01513" name="l01513"></a><span class="lineno"> 1513</span>    <span class="comment">/* ^-- Corner case: Suppose src.size() == 0.  The above then reduces to: if (!zero()) { m_size = m_start = 0; }</span></div>
<div class="line"><a id="l01514" name="l01514"></a><span class="lineno"> 1514</span><span class="comment">     * (Look inside its source code; you&#39;ll see.)</span></div>
<div class="line"><a id="l01515" name="l01515"></a><span class="lineno"> 1515</span><span class="comment">     *</span></div>
<div class="line"><a id="l01516" name="l01516"></a><span class="lineno"> 1516</span><span class="comment">     * We guarantee certain specific behavior in doc header, and below implements that.</span></div>
<div class="line"><a id="l01517" name="l01517"></a><span class="lineno"> 1517</span><span class="comment">     * We will indicate how it does so; but ALSO why those promises are made in the first place (rationale).</span></div>
<div class="line"><a id="l01518" name="l01518"></a><span class="lineno"> 1518</span><span class="comment">     *</span></div>
<div class="line"><a id="l01519" name="l01519"></a><span class="lineno"> 1519</span><span class="comment">     * In fact, we will proceed under the following priorities, highest to lowest:</span></div>
<div class="line"><a id="l01520" name="l01520"></a><span class="lineno"> 1520</span><span class="comment">     *   - User CAN switch order of our priorities sufficiently easily.</span></div>
<div class="line"><a id="l01521" name="l01521"></a><span class="lineno"> 1521</span><span class="comment">     *   - Be as fast as possible, excluding minimizing constant-time operations such as scalar assignments.</span></div>
<div class="line"><a id="l01522" name="l01522"></a><span class="lineno"> 1522</span><span class="comment">     *   - Use as little memory in *this as possible.</span></div>
<div class="line"><a id="l01523" name="l01523"></a><span class="lineno"> 1523</span><span class="comment">     *</span></div>
<div class="line"><a id="l01524" name="l01524"></a><span class="lineno"> 1524</span><span class="comment">     * We will NOT attempt to make *this have the same internal structure as src as its own independent virtue.</span></div>
<div class="line"><a id="l01525" name="l01525"></a><span class="lineno"> 1525</span><span class="comment">     * That doesn&#39;t seem useful and would make things more difficult obviously.  Now:</span></div>
<div class="line"><a id="l01526" name="l01526"></a><span class="lineno"> 1526</span><span class="comment">     *</span></div>
<div class="line"><a id="l01527" name="l01527"></a><span class="lineno"> 1527</span><span class="comment">     * Either src.zero(), or not; but regardless src.size() == 0.  Our options are essentially these:</span></div>
<div class="line"><a id="l01528" name="l01528"></a><span class="lineno"> 1528</span><span class="comment">     * make_zero(); or resize(0, 0).  (We could also perhaps copy src.m_buf_ptr[] and then adjust m_size = 0, but</span></div>
<div class="line"><a id="l01529" name="l01529"></a><span class="lineno"> 1529</span><span class="comment">     * this is clearly slower and only gains the thing we specifically pointed out is not a virtue above.)</span></div>
<div class="line"><a id="l01530" name="l01530"></a><span class="lineno"> 1530</span><span class="comment">     *</span></div>
<div class="line"><a id="l01531" name="l01531"></a><span class="lineno"> 1531</span><span class="comment">     * Let&#39;s break down those 2 courses of action, by situation, then:</span></div>
<div class="line"><a id="l01532" name="l01532"></a><span class="lineno"> 1532</span><span class="comment">     * - zero() &amp;&amp; src.zero(): make_zero() and resize(0, 0) are equivalent; so nothing to decide.  Either would be fine.</span></div>
<div class="line"><a id="l01533" name="l01533"></a><span class="lineno"> 1533</span><span class="comment">     * - zero() &amp;&amp; !src.zero(): Ditto.</span></div>
<div class="line"><a id="l01534" name="l01534"></a><span class="lineno"> 1534</span><span class="comment">     * - !zero() &amp;&amp; !src.zero(): make_zero() is slower than resize(0, 0); and moreover the latter may mean faster</span></div>
<div class="line"><a id="l01535" name="l01535"></a><span class="lineno"> 1535</span><span class="comment">     *   operations subsequently, if they subsequently choose to reserve(N) (including resize(N), etc.) to</span></div>
<div class="line"><a id="l01536" name="l01536"></a><span class="lineno"> 1536</span><span class="comment">     *   N &lt;= capacity().  So resize(0, 0) wins according to the priority order listed above.</span></div>
<div class="line"><a id="l01537" name="l01537"></a><span class="lineno"> 1537</span><span class="comment">     * - !zero() &amp;&amp; src.zero(): Ditto.</span></div>
<div class="line"><a id="l01538" name="l01538"></a><span class="lineno"> 1538</span><span class="comment">     *</span></div>
<div class="line"><a id="l01539" name="l01539"></a><span class="lineno"> 1539</span><span class="comment">     * So then we decided: resize(0, 0).  And, indeed, resize(0, 0) is equivalent to the above snippet.</span></div>
<div class="line"><a id="l01540" name="l01540"></a><span class="lineno"> 1540</span><span class="comment">     * So, we&#39;re good. */</span></div>
<div class="line"><a id="l01541" name="l01541"></a><span class="lineno"> 1541</span>  } <span class="comment">// if (this != &amp;src)</span></div>
<div class="line"><a id="l01542" name="l01542"></a><span class="lineno"> 1542</span> </div>
<div class="line"><a id="l01543" name="l01543"></a><span class="lineno"> 1543</span>  <span class="keywordflow">return</span> *<span class="keyword">this</span>;</div>
<div class="line"><a id="l01544" name="l01544"></a><span class="lineno"> 1544</span>} <span class="comment">// Basic_blob::assign(copy)</span></div>
<div class="line"><a id="l01545" name="l01545"></a><span class="lineno"> 1545</span> </div>
<div class="line"><a id="l01546" name="l01546"></a><span class="lineno"> 1546</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01547" name="l01547"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a72eda661d71306c2fbd0422993922309"> 1547</a></span><a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a151d35b3c35219089d53061503841b75">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::operator=</a>(<span class="keyword">const</span> <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; src)</div>
<div class="line"><a id="l01548" name="l01548"></a><span class="lineno"> 1548</span>{</div>
<div class="line"><a id="l01549" name="l01549"></a><span class="lineno"> 1549</span>  <span class="keywordflow">return</span> assign(src);</div>
<div class="line"><a id="l01550" name="l01550"></a><span class="lineno"> 1550</span>}</div>
<div class="line"><a id="l01551" name="l01551"></a><span class="lineno"> 1551</span> </div>
<div class="line"><a id="l01552" name="l01552"></a><span class="lineno"> 1552</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01553" name="l01553"></a><span class="lineno"> 1553</span><a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a>&amp;</div>
<div class="line"><a id="l01554" name="l01554"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a77785988abe56d62dacf42ec6a733713"> 1554</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a77785988abe56d62dacf42ec6a733713">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::assign</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp;&amp; moved_src, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01555" name="l01555"></a><span class="lineno"> 1555</span>{</div>
<div class="line"><a id="l01556" name="l01556"></a><span class="lineno"> 1556</span>  <span class="keywordflow">if</span> (<span class="keyword">this</span> != &amp;moved_src)</div>
<div class="line"><a id="l01557" name="l01557"></a><span class="lineno"> 1557</span>  {</div>
<div class="line"><a id="l01558" name="l01558"></a><span class="lineno"> 1558</span>    <span class="comment">// For m_alloc_raw: Follow rules established in m_alloc_raw doc header.</span></div>
<div class="line"><a id="l01559" name="l01559"></a><span class="lineno"> 1559</span>    <span class="keywordflow">if</span> <span class="keyword">constexpr</span>(std::allocator_traits&lt;Allocator_raw&gt;::propagate_on_container_move_assignment::value)</div>
<div class="line"><a id="l01560" name="l01560"></a><span class="lineno"> 1560</span>    {</div>
<div class="line"><a id="l01561" name="l01561"></a><span class="lineno"> 1561</span>      m_alloc_raw = std::move(moved_src.m_alloc_raw);</div>
<div class="line"><a id="l01562" name="l01562"></a><span class="lineno"> 1562</span>      <span class="comment">/* Let&#39;s consider what just happened.  Allocator_raw&#39;s policy is to, yes, move m_alloc_raw from</span></div>
<div class="line"><a id="l01563" name="l01563"></a><span class="lineno"> 1563</span><span class="comment">       * src to *this; so we did -- I guess src.m_alloc_raw is some null-ish empty-ish thing now.</span></div>
<div class="line"><a id="l01564" name="l01564"></a><span class="lineno"> 1564</span><span class="comment">       * Now suppose !zero() and !moved_src.zero(); and that old m_alloc_raw != new src.m_alloc_raw.</span></div>
<div class="line"><a id="l01565" name="l01565"></a><span class="lineno"> 1565</span><span class="comment">       * (That is fairly exotic; at least Allocator_raw is stateful to begin with.</span></div>
<div class="line"><a id="l01566" name="l01566"></a><span class="lineno"> 1566</span><span class="comment">       * E.g., boost::interprocess::allocator&lt;&gt;s with same type but set to different SHM pools S1 and S2 would</span></div>
<div class="line"><a id="l01567" name="l01567"></a><span class="lineno"> 1567</span><span class="comment">       * compare unequal.)  What needs to happen is m_buf_ptr buffer must be freed (more accurately, its</span></div>
<div class="line"><a id="l01568" name="l01568"></a><span class="lineno"> 1568</span><span class="comment">       * shared_ptr ref_count decremented and thus buffer possibly freed if not share()d) + ptr nullified); then ideally</span></div>
<div class="line"><a id="l01569" name="l01569"></a><span class="lineno"> 1569</span><span class="comment">       * simply swap m_buf_ptr (which will get moved_src.m_buf_ptr old value) and moved_src.m_buf_ptr (which will</span></div>
<div class="line"><a id="l01570" name="l01570"></a><span class="lineno"> 1570</span><span class="comment">       * become null).  That&#39;s what we do below.  So will it work?</span></div>
<div class="line"><a id="l01571" name="l01571"></a><span class="lineno"> 1571</span><span class="comment">       *   -# The m_buf_ptr.reset() below will work fine for the same reason the long comment in assign(copy)</span></div>
<div class="line"><a id="l01572" name="l01572"></a><span class="lineno"> 1572</span><span class="comment">       *      states that nullifying m_buf_ptr, even with m_alloc_raw already replaced, will still use old m_alloc_raw:</span></div>
<div class="line"><a id="l01573" name="l01573"></a><span class="lineno"> 1573</span><span class="comment">       *      for it is stored inside the central area linked-to in the m_buf_ptr being nullified.</span></div>
<div class="line"><a id="l01574" name="l01574"></a><span class="lineno"> 1574</span><span class="comment">       *   -# The swap is absolutely smooth and fine.  And indeed by making that swap we&#39;ll&#39;ve ensured this-&gt;m_alloc_raw</span></div>
<div class="line"><a id="l01575" name="l01575"></a><span class="lineno"> 1575</span><span class="comment">       *      and the allocator stored inside m_buf_ptr are equal. */</span></div>
<div class="line"><a id="l01576" name="l01576"></a><span class="lineno"> 1576</span>    }</div>
<div class="line"><a id="l01577" name="l01577"></a><span class="lineno"> 1577</span>    <span class="comment">/* else: Leave m_alloc_raw alone.  What does it mean though?  Let&#39;s consider it.  Suppose !zero() and</span></div>
<div class="line"><a id="l01578" name="l01578"></a><span class="lineno"> 1578</span><span class="comment">     * !moved_src.zero(), and the two `m_alloc_raw`s do not compare equal (e.g., boost::interprocess::allocator&lt;&gt;s</span></div>
<div class="line"><a id="l01579" name="l01579"></a><span class="lineno"> 1579</span><span class="comment">     * with mutually differing SHM-pools).  m_buf_ptr.reset() below will work fine: m_alloc_raw is unchanged so no</span></div>
<div class="line"><a id="l01580" name="l01580"></a><span class="lineno"> 1580</span><span class="comment">     * controversy.  However once m_buf_ptr is moved from moved_src.m_buf_ptr, it will (same reason as above --</span></div>
<div class="line"><a id="l01581" name="l01581"></a><span class="lineno"> 1581</span><span class="comment">     * it is cached) keep using old m_alloc_raw; meaning if/when it is .reset() or destroyed the old allocator</span></div>
<div class="line"><a id="l01582" name="l01582"></a><span class="lineno"> 1582</span><span class="comment">     * will deallocate.  That is in fact what we want.  It might seem odd that m_alloc_raw won&#39;t match what&#39;s</span></div>
<div class="line"><a id="l01583" name="l01583"></a><span class="lineno"> 1583</span><span class="comment">     * used for this-&gt;m_buf_ptr, but it is fine: m_alloc_raw affects the *next* allocating reserve().</span></div>
<div class="line"><a id="l01584" name="l01584"></a><span class="lineno"> 1584</span><span class="comment">     * (And, as usual, if Allocator_raw is stateless, then none of this matters.) */</span></div>
<div class="line"><a id="l01585" name="l01585"></a><span class="lineno"> 1585</span> </div>
<div class="line"><a id="l01586" name="l01586"></a><span class="lineno"> 1586</span>    <span class="comment">// Now to the relatively uncontroversial stuff.</span></div>
<div class="line"><a id="l01587" name="l01587"></a><span class="lineno"> 1587</span> </div>
<div class="line"><a id="l01588" name="l01588"></a><span class="lineno"> 1588</span>    make_zero(logger_ptr); <span class="comment">// Spoiler alert: it&#39;s: if (!zero()) { m_buf_ptr.reset(); }</span></div>
<div class="line"><a id="l01589" name="l01589"></a><span class="lineno"> 1589</span>    <span class="comment">// So now m_buf_ptr is null; hence the other m_* (other than m_alloc_raw) are meaningless.</span></div>
<div class="line"><a id="l01590" name="l01590"></a><span class="lineno"> 1590</span> </div>
<div class="line"><a id="l01591" name="l01591"></a><span class="lineno"> 1591</span>    swap_impl(moved_src, logger_ptr);</div>
<div class="line"><a id="l01592" name="l01592"></a><span class="lineno"> 1592</span>    <span class="comment">// Now *this is equal to old moved_src; new moved_src is valid and zero(); and nothing was copied -- as advertised.</span></div>
<div class="line"><a id="l01593" name="l01593"></a><span class="lineno"> 1593</span>  } <span class="comment">// if (this != &amp;moved_src)</span></div>
<div class="line"><a id="l01594" name="l01594"></a><span class="lineno"> 1594</span> </div>
<div class="line"><a id="l01595" name="l01595"></a><span class="lineno"> 1595</span>  <span class="keywordflow">return</span> *<span class="keyword">this</span>;</div>
<div class="line"><a id="l01596" name="l01596"></a><span class="lineno"> 1596</span>} <span class="comment">// Basic_blob::assign(move)</span></div>
<div class="line"><a id="l01597" name="l01597"></a><span class="lineno"> 1597</span> </div>
<div class="line"><a id="l01598" name="l01598"></a><span class="lineno"> 1598</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01599" name="l01599"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a151d35b3c35219089d53061503841b75"> 1599</a></span><a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a>&amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a151d35b3c35219089d53061503841b75">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::operator=</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp;&amp; moved_src)</div>
<div class="line"><a id="l01600" name="l01600"></a><span class="lineno"> 1600</span>{</div>
<div class="line"><a id="l01601" name="l01601"></a><span class="lineno"> 1601</span>  <span class="keywordflow">return</span> assign(std::move(moved_src));</div>
<div class="line"><a id="l01602" name="l01602"></a><span class="lineno"> 1602</span>}</div>
<div class="line"><a id="l01603" name="l01603"></a><span class="lineno"> 1603</span> </div>
<div class="line"><a id="l01604" name="l01604"></a><span class="lineno"> 1604</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01605" name="l01605"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#adc0bb760b5f2f36147d128e2e5fbe95f"> 1605</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#adc0bb760b5f2f36147d128e2e5fbe95f">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::swap_impl</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; other, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01606" name="l01606"></a><span class="lineno"> 1606</span>{</div>
<div class="line"><a id="l01607" name="l01607"></a><span class="lineno"> 1607</span>  <span class="keyword">using </span><a class="code hl_function" href="namespaceflow_1_1util.html#a71eaa4ab6a2673ed34fa8989c47a7bc0">std::swap</a>;</div>
<div class="line"><a id="l01608" name="l01608"></a><span class="lineno"> 1608</span> </div>
<div class="line"><a id="l01609" name="l01609"></a><span class="lineno"> 1609</span>  <span class="keywordflow">if</span> (<span class="keyword">this</span> != &amp;other)</div>
<div class="line"><a id="l01610" name="l01610"></a><span class="lineno"> 1610</span>  {</div>
<div class="line"><a id="l01611" name="l01611"></a><span class="lineno"> 1611</span>    <span class="keywordflow">if</span> (logger_ptr &amp;&amp; logger_ptr-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">log::Sev::S_TRACE</a>, S_LOG_COMPONENT))</div>
<div class="line"><a id="l01612" name="l01612"></a><span class="lineno"> 1612</span>    {</div>
<div class="line"><a id="l01613" name="l01613"></a><span class="lineno"> 1613</span>      <a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(logger_ptr, S_LOG_COMPONENT);</div>
<div class="line"><a id="l01614" name="l01614"></a><span class="lineno"> 1614</span>      <a class="code hl_define" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a>(<span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; <span class="keyword">this</span> &lt;&lt; <span class="stringliteral">&quot;] (internal buffer sized [&quot;</span> &lt;&lt; capacity() &lt;&lt; <span class="stringliteral">&quot;]) &quot;</span></div>
<div class="line"><a id="l01615" name="l01615"></a><span class="lineno"> 1615</span>                                      <span class="stringliteral">&quot;swapping &lt;=&gt; Blob [&quot;</span> &lt;&lt; &amp;other &lt;&lt; <span class="stringliteral">&quot;] (internal buffer sized &quot;</span></div>
<div class="line"><a id="l01616" name="l01616"></a><span class="lineno"> 1616</span>                                      <span class="stringliteral">&quot;[&quot;</span> &lt;&lt; other.<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a719e5c04e4bdc65c31976fc385fd7f24">capacity</a>() &lt;&lt; <span class="stringliteral">&quot;]).&quot;</span>);</div>
<div class="line"><a id="l01617" name="l01617"></a><span class="lineno"> 1617</span>    }</div>
<div class="line"><a id="l01618" name="l01618"></a><span class="lineno"> 1618</span> </div>
<div class="line"><a id="l01619" name="l01619"></a><span class="lineno"> 1619</span>    <a class="code hl_function" href="namespaceflow_1_1util.html#a71eaa4ab6a2673ed34fa8989c47a7bc0">swap</a>(m_buf_ptr, other.<a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#a45b5f98e106d0cd36956063cd859d3c6">m_buf_ptr</a>);</div>
<div class="line"><a id="l01620" name="l01620"></a><span class="lineno"> 1620</span> </div>
<div class="line"><a id="l01621" name="l01621"></a><span class="lineno"> 1621</span>    <span class="comment">/* Some compilers in some build configs issue maybe-uninitialized warning here, when `other` is as-if</span></div>
<div class="line"><a id="l01622" name="l01622"></a><span class="lineno"> 1622</span><span class="comment">     * default-cted (hence the following three are intentionally uninitialized), particularly with heavy</span></div>
<div class="line"><a id="l01623" name="l01623"></a><span class="lineno"> 1623</span><span class="comment">     * auto-inlining by the optimizer.  False positive in our case, and in Blob-land we try not to give away perf</span></div>
<div class="line"><a id="l01624" name="l01624"></a><span class="lineno"> 1624</span><span class="comment">     * at all so: */</span></div>
<div class="line"><a id="l01625" name="l01625"></a><span class="lineno"> 1625</span><span class="preprocessor">#pragma GCC diagnostic push</span></div>
<div class="line"><a id="l01626" name="l01626"></a><span class="lineno"> 1626</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wpragmas&quot;</span> <span class="comment">// For older versions, where the following does not exist/cannot be disabled.</span></div>
<div class="line"><a id="l01627" name="l01627"></a><span class="lineno"> 1627</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wunknown-warning-option&quot;</span> <span class="comment">// (Similarly for clang.)</span></div>
<div class="line"><a id="l01628" name="l01628"></a><span class="lineno"> 1628</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wmaybe-uninitialized&quot;</span></div>
<div class="line"><a id="l01629" name="l01629"></a><span class="lineno"> 1629</span> </div>
<div class="line"><a id="l01630" name="l01630"></a><span class="lineno"> 1630</span>    <a class="code hl_function" href="namespaceflow_1_1util.html#a71eaa4ab6a2673ed34fa8989c47a7bc0">swap</a>(m_capacity, other.<a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#a1f2d99a5b487a454af627e8e33738abf">m_capacity</a>); <span class="comment">// Meaningless if zero() but harmless.</span></div>
<div class="line"><a id="l01631" name="l01631"></a><span class="lineno"> 1631</span>    <a class="code hl_function" href="namespaceflow_1_1util.html#a71eaa4ab6a2673ed34fa8989c47a7bc0">swap</a>(m_size, other.<a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#ac008b60f7fe4253be9527436b0661dcc">m_size</a>); <span class="comment">// Ditto.</span></div>
<div class="line"><a id="l01632" name="l01632"></a><span class="lineno"> 1632</span>    <a class="code hl_function" href="namespaceflow_1_1util.html#a71eaa4ab6a2673ed34fa8989c47a7bc0">swap</a>(m_start, other.<a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#aae53d36a27090ef5da931bc17d4f2bcd">m_start</a>); <span class="comment">// Ditto.</span></div>
<div class="line"><a id="l01633" name="l01633"></a><span class="lineno"> 1633</span> </div>
<div class="line"><a id="l01634" name="l01634"></a><span class="lineno"> 1634</span><span class="preprocessor">#pragma GCC diagnostic pop</span></div>
<div class="line"><a id="l01635" name="l01635"></a><span class="lineno"> 1635</span> </div>
<div class="line"><a id="l01636" name="l01636"></a><span class="lineno"> 1636</span>    <span class="comment">/* Skip m_alloc_raw: swap() has to do it by itself; we are called from it + move-assign/ctor which require</span></div>
<div class="line"><a id="l01637" name="l01637"></a><span class="lineno"> 1637</span><span class="comment">     * mutually different treatment for m_alloc_raw. */</span></div>
<div class="line"><a id="l01638" name="l01638"></a><span class="lineno"> 1638</span>  }</div>
<div class="line"><a id="l01639" name="l01639"></a><span class="lineno"> 1639</span>} <span class="comment">// Basic_blob::swap_impl()</span></div>
<div class="line"><a id="l01640" name="l01640"></a><span class="lineno"> 1640</span> </div>
<div class="line"><a id="l01641" name="l01641"></a><span class="lineno"> 1641</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01642" name="l01642"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a3707ab8d2693a394c661b742d2626d4e"> 1642</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a3707ab8d2693a394c661b742d2626d4e">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::swap</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp; other, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01643" name="l01643"></a><span class="lineno"> 1643</span>{</div>
<div class="line"><a id="l01644" name="l01644"></a><span class="lineno"> 1644</span>  <span class="keyword">using </span><a class="code hl_function" href="namespaceflow_1_1util.html#a71eaa4ab6a2673ed34fa8989c47a7bc0">std::swap</a>;</div>
<div class="line"><a id="l01645" name="l01645"></a><span class="lineno"> 1645</span> </div>
<div class="line"><a id="l01646" name="l01646"></a><span class="lineno"> 1646</span>  <span class="comment">// For m_alloc_raw: Follow rules established in m_alloc_raw doc header.</span></div>
<div class="line"><a id="l01647" name="l01647"></a><span class="lineno"> 1647</span>  <span class="keywordflow">if</span> <span class="keyword">constexpr</span>(std::allocator_traits&lt;Allocator_raw&gt;::propagate_on_container_swap::value)</div>
<div class="line"><a id="l01648" name="l01648"></a><span class="lineno"> 1648</span>  {</div>
<div class="line"><a id="l01649" name="l01649"></a><span class="lineno"> 1649</span>    <span class="keywordflow">if</span> (&amp;m_alloc_raw != &amp;other.<a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#ac7478166f4244b068a8793dc90b1f9e4">m_alloc_raw</a>) <span class="comment">// @todo Is this redundant?  Or otherwise unnecessary?</span></div>
<div class="line"><a id="l01650" name="l01650"></a><span class="lineno"> 1650</span>    {</div>
<div class="line"><a id="l01651" name="l01651"></a><span class="lineno"> 1651</span>      <a class="code hl_function" href="namespaceflow_1_1util.html#a71eaa4ab6a2673ed34fa8989c47a7bc0">swap</a>(m_alloc_raw, other.<a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#ac7478166f4244b068a8793dc90b1f9e4">m_alloc_raw</a>);</div>
<div class="line"><a id="l01652" name="l01652"></a><span class="lineno"> 1652</span>    }</div>
<div class="line"><a id="l01653" name="l01653"></a><span class="lineno"> 1653</span>  }</div>
<div class="line"><a id="l01654" name="l01654"></a><span class="lineno"> 1654</span>  <span class="comment">/* else: Leave both `m_alloc_raw`s alone.  What does it mean though?  Well, see either assign(); the same</span></div>
<div class="line"><a id="l01655" name="l01655"></a><span class="lineno"> 1655</span><span class="comment">   * theme applies here: Each m_buf_ptr&#39;s cached allocator/deleter will potentially not equal its respective</span></div>
<div class="line"><a id="l01656" name="l01656"></a><span class="lineno"> 1656</span><span class="comment">   * m_alloc_raw anymore; but the latter affects only the *next* allocating reserve(); so it is fine.</span></div>
<div class="line"><a id="l01657" name="l01657"></a><span class="lineno"> 1657</span><span class="comment">   * That said, to quote cppreference.com: &quot;Note: swapping two containers with unequal allocators if</span></div>
<div class="line"><a id="l01658" name="l01658"></a><span class="lineno"> 1658</span><span class="comment">   * propagate_on_container_swap is false is undefined behavior.&quot;  So, while it will work for us, trying such</span></div>
<div class="line"><a id="l01659" name="l01659"></a><span class="lineno"> 1659</span><span class="comment">   * a swap() would be illegal user behavior in any case. */</span></div>
<div class="line"><a id="l01660" name="l01660"></a><span class="lineno"> 1660</span> </div>
<div class="line"><a id="l01661" name="l01661"></a><span class="lineno"> 1661</span>  <span class="comment">// Now to the relatively uncontroversial stuff.</span></div>
<div class="line"><a id="l01662" name="l01662"></a><span class="lineno"> 1662</span>  swap_impl(other, logger_ptr);</div>
<div class="line"><a id="l01663" name="l01663"></a><span class="lineno"> 1663</span>}</div>
<div class="line"><a id="l01664" name="l01664"></a><span class="lineno"> 1664</span> </div>
<div class="line"><a id="l01665" name="l01665"></a><span class="lineno"> 1665</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01666" name="l01666"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a71eaa4ab6a2673ed34fa8989c47a7bc0"> 1666</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="namespaceflow_1_1util.html#a71eaa4ab6a2673ed34fa8989c47a7bc0">swap</a>(<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a>&amp; blob1,</div>
<div class="line"><a id="l01667" name="l01667"></a><span class="lineno"> 1667</span>          <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a>&amp; blob2, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01668" name="l01668"></a><span class="lineno"> 1668</span>{</div>
<div class="line"><a id="l01669" name="l01669"></a><span class="lineno"> 1669</span>  <span class="keywordflow">return</span> blob1.<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a3707ab8d2693a394c661b742d2626d4e">swap</a>(blob2, logger_ptr);</div>
<div class="line"><a id="l01670" name="l01670"></a><span class="lineno"> 1670</span>}</div>
<div class="line"><a id="l01671" name="l01671"></a><span class="lineno"> 1671</span> </div>
<div class="line"><a id="l01672" name="l01672"></a><span class="lineno"> 1672</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01673" name="l01673"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a0044410b7d1f541978a309f02b2739d3"> 1673</a></span><a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a0044410b7d1f541978a309f02b2739d3">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::share</a>(<a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)<span class="keyword"> const</span></div>
<div class="line"><a id="l01674" name="l01674"></a><span class="lineno"> 1674</span><span class="keyword"></span>{</div>
<div class="line"><a id="l01675" name="l01675"></a><span class="lineno"> 1675</span>  <span class="keyword">static_assert</span>(S_SHARING,</div>
<div class="line"><a id="l01676" name="l01676"></a><span class="lineno"> 1676</span>                <span class="stringliteral">&quot;Do not invoke (and thus instantiate) share() or derived methods unless you set the S_SHARING_ALLOWED &quot;</span></div>
<div class="line"><a id="l01677" name="l01677"></a><span class="lineno"> 1677</span>                  <span class="stringliteral">&quot;template parameter to true.  Sharing will be enabled at a small perf cost; see class doc header.&quot;</span>);</div>
<div class="line"><a id="l01678" name="l01678"></a><span class="lineno"> 1678</span>  <span class="comment">// Note: The guys that call it will cause the same check to occur, since instantiating them will instantiate us.</span></div>
<div class="line"><a id="l01679" name="l01679"></a><span class="lineno"> 1679</span> </div>
<div class="line"><a id="l01680" name="l01680"></a><span class="lineno"> 1680</span>  assert(!zero()); <span class="comment">// As advertised.</span></div>
<div class="line"><a id="l01681" name="l01681"></a><span class="lineno"> 1681</span> </div>
<div class="line"><a id="l01682" name="l01682"></a><span class="lineno"> 1682</span>  <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a> sharing_blob{m_alloc_raw, logger_ptr}; <span class="comment">// Null Basic_blob (let that ctor log via same Logger if any).</span></div>
<div class="line"><a id="l01683" name="l01683"></a><span class="lineno"> 1683</span>  assert(!sharing_blob.m_buf_ptr);</div>
<div class="line"><a id="l01684" name="l01684"></a><span class="lineno"> 1684</span>  sharing_blob.m_buf_ptr = m_buf_ptr;</div>
<div class="line"><a id="l01685" name="l01685"></a><span class="lineno"> 1685</span>  <span class="comment">// These are currently (as of this writing) uninitialized (possibly garbage).</span></div>
<div class="line"><a id="l01686" name="l01686"></a><span class="lineno"> 1686</span>  sharing_blob.m_capacity = m_capacity;</div>
<div class="line"><a id="l01687" name="l01687"></a><span class="lineno"> 1687</span>  sharing_blob.m_start = m_start;</div>
<div class="line"><a id="l01688" name="l01688"></a><span class="lineno"> 1688</span>  sharing_blob.m_size = m_size;</div>
<div class="line"><a id="l01689" name="l01689"></a><span class="lineno"> 1689</span> </div>
<div class="line"><a id="l01690" name="l01690"></a><span class="lineno"> 1690</span>  <span class="keywordflow">if</span> (logger_ptr &amp;&amp; logger_ptr-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">log::Sev::S_TRACE</a>, S_LOG_COMPONENT))</div>
<div class="line"><a id="l01691" name="l01691"></a><span class="lineno"> 1691</span>  {</div>
<div class="line"><a id="l01692" name="l01692"></a><span class="lineno"> 1692</span>    <a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(logger_ptr, S_LOG_COMPONENT);</div>
<div class="line"><a id="l01693" name="l01693"></a><span class="lineno"> 1693</span>    <a class="code hl_define" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a></div>
<div class="line"><a id="l01694" name="l01694"></a><span class="lineno"> 1694</span>      (<span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; <span class="keyword">this</span> &lt;&lt; <span class="stringliteral">&quot;] shared with new Blob [&quot;</span> &lt;&lt; &amp;sharing_blob &lt;&lt; <span class="stringliteral">&quot;]; ref-count incremented.&quot;</span>);</div>
<div class="line"><a id="l01695" name="l01695"></a><span class="lineno"> 1695</span>  }</div>
<div class="line"><a id="l01696" name="l01696"></a><span class="lineno"> 1696</span> </div>
<div class="line"><a id="l01697" name="l01697"></a><span class="lineno"> 1697</span>  <span class="keywordflow">return</span> sharing_blob;</div>
<div class="line"><a id="l01698" name="l01698"></a><span class="lineno"> 1698</span>}</div>
<div class="line"><a id="l01699" name="l01699"></a><span class="lineno"> 1699</span> </div>
<div class="line"><a id="l01700" name="l01700"></a><span class="lineno"> 1700</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01701" name="l01701"></a><span class="lineno"> 1701</span><a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a></div>
<div class="line"><a id="l01702" name="l01702"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a6c0635640d16084eb975a9fb97f96aab"> 1702</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a6c0635640d16084eb975a9fb97f96aab">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::share_after_split_left</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> lt_size, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01703" name="l01703"></a><span class="lineno"> 1703</span>{</div>
<div class="line"><a id="l01704" name="l01704"></a><span class="lineno"> 1704</span>  <span class="keywordflow">if</span> (lt_size &gt; size())</div>
<div class="line"><a id="l01705" name="l01705"></a><span class="lineno"> 1705</span>  {</div>
<div class="line"><a id="l01706" name="l01706"></a><span class="lineno"> 1706</span>    lt_size = size();</div>
<div class="line"><a id="l01707" name="l01707"></a><span class="lineno"> 1707</span>  }</div>
<div class="line"><a id="l01708" name="l01708"></a><span class="lineno"> 1708</span> </div>
<div class="line"><a id="l01709" name="l01709"></a><span class="lineno"> 1709</span>  <span class="keywordflow">if</span> (logger_ptr &amp;&amp; logger_ptr-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">log::Sev::S_TRACE</a>, S_LOG_COMPONENT))</div>
<div class="line"><a id="l01710" name="l01710"></a><span class="lineno"> 1710</span>  {</div>
<div class="line"><a id="l01711" name="l01711"></a><span class="lineno"> 1711</span>    <a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(logger_ptr, S_LOG_COMPONENT);</div>
<div class="line"><a id="l01712" name="l01712"></a><span class="lineno"> 1712</span>    <a class="code hl_define" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a>(<span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; <span class="keyword">this</span> &lt;&lt; <span class="stringliteral">&quot;] shall be shared with new Blob, splitting off the first &quot;</span></div>
<div class="line"><a id="l01713" name="l01713"></a><span class="lineno"> 1713</span>                                    <span class="stringliteral">&quot;[&quot;</span> &lt;&lt; lt_size &lt;&lt; <span class="stringliteral">&quot;] values into that one and leaving the remaining &quot;</span></div>
<div class="line"><a id="l01714" name="l01714"></a><span class="lineno"> 1714</span>                                    <span class="stringliteral">&quot;[&quot;</span> &lt;&lt; (size() - lt_size) &lt;&lt; <span class="stringliteral">&quot;] in this one.&quot;</span>);</div>
<div class="line"><a id="l01715" name="l01715"></a><span class="lineno"> 1715</span>  }</div>
<div class="line"><a id="l01716" name="l01716"></a><span class="lineno"> 1716</span> </div>
<div class="line"><a id="l01717" name="l01717"></a><span class="lineno"> 1717</span>  <span class="keyword">auto</span> sharing_blob = share(logger_ptr); <span class="comment">// sharing_blob sub-Basic_blob is equal to *this sub-Basic_blob.  Adjust:</span></div>
<div class="line"><a id="l01718" name="l01718"></a><span class="lineno"> 1718</span>  sharing_blob.resize(lt_size); <span class="comment">// Note: sharing_blob.start() remains unchanged.</span></div>
<div class="line"><a id="l01719" name="l01719"></a><span class="lineno"> 1719</span>  start_past_prefix_inc(lt_size);</div>
<div class="line"><a id="l01720" name="l01720"></a><span class="lineno"> 1720</span> </div>
<div class="line"><a id="l01721" name="l01721"></a><span class="lineno"> 1721</span>  <span class="keywordflow">return</span> sharing_blob;</div>
<div class="line"><a id="l01722" name="l01722"></a><span class="lineno"> 1722</span>}</div>
<div class="line"><a id="l01723" name="l01723"></a><span class="lineno"> 1723</span> </div>
<div class="line"><a id="l01724" name="l01724"></a><span class="lineno"> 1724</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01725" name="l01725"></a><span class="lineno"> 1725</span><a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a></div>
<div class="line"><a id="l01726" name="l01726"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aedd12dc6003934e156e3dc100e7c193e"> 1726</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#aedd12dc6003934e156e3dc100e7c193e">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::share_after_split_right</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> rt_size, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01727" name="l01727"></a><span class="lineno"> 1727</span>{</div>
<div class="line"><a id="l01728" name="l01728"></a><span class="lineno"> 1728</span>  <span class="keywordflow">if</span> (rt_size &gt; size())</div>
<div class="line"><a id="l01729" name="l01729"></a><span class="lineno"> 1729</span>  {</div>
<div class="line"><a id="l01730" name="l01730"></a><span class="lineno"> 1730</span>    rt_size = size();</div>
<div class="line"><a id="l01731" name="l01731"></a><span class="lineno"> 1731</span>  }</div>
<div class="line"><a id="l01732" name="l01732"></a><span class="lineno"> 1732</span> </div>
<div class="line"><a id="l01733" name="l01733"></a><span class="lineno"> 1733</span>  <span class="keyword">const</span> <span class="keyword">auto</span> lt_size = size() - rt_size;</div>
<div class="line"><a id="l01734" name="l01734"></a><span class="lineno"> 1734</span>  <span class="keywordflow">if</span> (logger_ptr &amp;&amp; logger_ptr-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">log::Sev::S_TRACE</a>, S_LOG_COMPONENT))</div>
<div class="line"><a id="l01735" name="l01735"></a><span class="lineno"> 1735</span>  {</div>
<div class="line"><a id="l01736" name="l01736"></a><span class="lineno"> 1736</span>    <a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(logger_ptr, S_LOG_COMPONENT);</div>
<div class="line"><a id="l01737" name="l01737"></a><span class="lineno"> 1737</span>    <a class="code hl_define" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a>(<span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; <span class="keyword">this</span> &lt;&lt; <span class="stringliteral">&quot;] shall be shared with new Blob, splitting off &quot;</span></div>
<div class="line"><a id="l01738" name="l01738"></a><span class="lineno"> 1738</span>                                    <span class="stringliteral">&quot;the last [&quot;</span> &lt;&lt; rt_size &lt;&lt; <span class="stringliteral">&quot;] values into that one and leaving the &quot;</span></div>
<div class="line"><a id="l01739" name="l01739"></a><span class="lineno"> 1739</span>                                    <span class="stringliteral">&quot;remaining [&quot;</span> &lt;&lt; lt_size &lt;&lt; <span class="stringliteral">&quot;] in this one.&quot;</span>);</div>
<div class="line"><a id="l01740" name="l01740"></a><span class="lineno"> 1740</span>  }</div>
<div class="line"><a id="l01741" name="l01741"></a><span class="lineno"> 1741</span> </div>
<div class="line"><a id="l01742" name="l01742"></a><span class="lineno"> 1742</span>  <span class="keyword">auto</span> sharing_blob = share(logger_ptr); <span class="comment">// sharing_blob sub-Basic_blob is equal to *this sub-Basic_blob.  Adjust:</span></div>
<div class="line"><a id="l01743" name="l01743"></a><span class="lineno"> 1743</span>  resize(lt_size); <span class="comment">// Note: start() remains unchanged.</span></div>
<div class="line"><a id="l01744" name="l01744"></a><span class="lineno"> 1744</span>  sharing_blob.start_past_prefix_inc(lt_size);</div>
<div class="line"><a id="l01745" name="l01745"></a><span class="lineno"> 1745</span> </div>
<div class="line"><a id="l01746" name="l01746"></a><span class="lineno"> 1746</span>  <span class="keywordflow">return</span> sharing_blob;</div>
<div class="line"><a id="l01747" name="l01747"></a><span class="lineno"> 1747</span>}</div>
<div class="line"><a id="l01748" name="l01748"></a><span class="lineno"> 1748</span> </div>
<div class="line"><a id="l01749" name="l01749"></a><span class="lineno"> 1749</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01750" name="l01750"></a><span class="lineno"> 1750</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Emit_blob_func, <span class="keyword">typename</span> Share_after_split_left_func&gt;</div>
<div class="line"><a id="l01751" name="l01751"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a92215c61d9e3ca83bdbfa6b078b72dc9"> 1751</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a92215c61d9e3ca83bdbfa6b078b72dc9">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::share_after_split_equally_impl</a></div>
<div class="line"><a id="l01752" name="l01752"></a><span class="lineno"> 1752</span>       (<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> size, <span class="keywordtype">bool</span> headless_pool, Emit_blob_func&amp;&amp; emit_blob_func, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr,</div>
<div class="line"><a id="l01753" name="l01753"></a><span class="lineno"> 1753</span>        Share_after_split_left_func&amp;&amp; share_after_split_left_func)</div>
<div class="line"><a id="l01754" name="l01754"></a><span class="lineno"> 1754</span>{</div>
<div class="line"><a id="l01755" name="l01755"></a><span class="lineno"> 1755</span>  assert(size != 0);</div>
<div class="line"><a id="l01756" name="l01756"></a><span class="lineno"> 1756</span>  assert(!empty());</div>
<div class="line"><a id="l01757" name="l01757"></a><span class="lineno"> 1757</span> </div>
<div class="line"><a id="l01758" name="l01758"></a><span class="lineno"> 1758</span>  <span class="keywordflow">if</span> (logger_ptr &amp;&amp; logger_ptr-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">log::Sev::S_TRACE</a>, S_LOG_COMPONENT))</div>
<div class="line"><a id="l01759" name="l01759"></a><span class="lineno"> 1759</span>  {</div>
<div class="line"><a id="l01760" name="l01760"></a><span class="lineno"> 1760</span>    <a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(logger_ptr, S_LOG_COMPONENT);</div>
<div class="line"><a id="l01761" name="l01761"></a><span class="lineno"> 1761</span>    <a class="code hl_define" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a>(<span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; <span class="keyword">this</span> &lt;&lt; <span class="stringliteral">&quot;] of size [&quot;</span> &lt;&lt; this-&gt;size() &lt;&lt; <span class="stringliteral">&quot;] shall be split into &quot;</span></div>
<div class="line"><a id="l01762" name="l01762"></a><span class="lineno"> 1762</span>                                    <span class="stringliteral">&quot;adjacent sharing sub-Blobs of size [&quot;</span> &lt;&lt; size &lt;&lt; <span class="stringliteral">&quot;] each &quot;</span></div>
<div class="line"><a id="l01763" name="l01763"></a><span class="lineno"> 1763</span>                                    <span class="stringliteral">&quot;(last one possibly smaller).&quot;</span>);</div>
<div class="line"><a id="l01764" name="l01764"></a><span class="lineno"> 1764</span>  }</div>
<div class="line"><a id="l01765" name="l01765"></a><span class="lineno"> 1765</span> </div>
<div class="line"><a id="l01766" name="l01766"></a><span class="lineno"> 1766</span>  <span class="keywordflow">do</span></div>
<div class="line"><a id="l01767" name="l01767"></a><span class="lineno"> 1767</span>  {</div>
<div class="line"><a id="l01768" name="l01768"></a><span class="lineno"> 1768</span>    emit_blob_func(share_after_split_left_func(size, logger_ptr)); <span class="comment">// share_after_split_left_func() logs plenty.</span></div>
<div class="line"><a id="l01769" name="l01769"></a><span class="lineno"> 1769</span>  }</div>
<div class="line"><a id="l01770" name="l01770"></a><span class="lineno"> 1770</span>  <span class="keywordflow">while</span> (!empty());</div>
<div class="line"><a id="l01771" name="l01771"></a><span class="lineno"> 1771</span> </div>
<div class="line"><a id="l01772" name="l01772"></a><span class="lineno"> 1772</span>  <span class="keywordflow">if</span> (headless_pool)</div>
<div class="line"><a id="l01773" name="l01773"></a><span class="lineno"> 1773</span>  {</div>
<div class="line"><a id="l01774" name="l01774"></a><span class="lineno"> 1774</span>    make_zero(logger_ptr);</div>
<div class="line"><a id="l01775" name="l01775"></a><span class="lineno"> 1775</span>  }</div>
<div class="line"><a id="l01776" name="l01776"></a><span class="lineno"> 1776</span>} <span class="comment">// Basic_blob::share_after_split_equally_impl()</span></div>
<div class="line"><a id="l01777" name="l01777"></a><span class="lineno"> 1777</span> </div>
<div class="line"><a id="l01778" name="l01778"></a><span class="lineno"> 1778</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01779" name="l01779"></a><span class="lineno"> 1779</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Emit_blob_func&gt;</div>
<div class="line"><a id="l01780" name="l01780"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a2e4aa425939071a4fb313d3237987226"> 1780</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a2e4aa425939071a4fb313d3237987226">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::share_after_split_equally</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> size, <span class="keywordtype">bool</span> headless_pool,</div>
<div class="line"><a id="l01781" name="l01781"></a><span class="lineno"> 1781</span>                                                                         Emit_blob_func&amp;&amp; emit_blob_func,</div>
<div class="line"><a id="l01782" name="l01782"></a><span class="lineno"> 1782</span>                                                                         <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01783" name="l01783"></a><span class="lineno"> 1783</span>{</div>
<div class="line"><a id="l01784" name="l01784"></a><span class="lineno"> 1784</span>  share_after_split_equally_impl(size, headless_pool, std::move(emit_blob_func), logger_ptr,</div>
<div class="line"><a id="l01785" name="l01785"></a><span class="lineno"> 1785</span>                                 [<span class="keyword">this</span>](<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> lt_size, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr) -&gt; <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a></div>
<div class="line"><a id="l01786" name="l01786"></a><span class="lineno"> 1786</span>  {</div>
<div class="line"><a id="l01787" name="l01787"></a><span class="lineno"> 1787</span>    <span class="keywordflow">return</span> share_after_split_left(lt_size, logger_ptr);</div>
<div class="line"><a id="l01788" name="l01788"></a><span class="lineno"> 1788</span>  });</div>
<div class="line"><a id="l01789" name="l01789"></a><span class="lineno"> 1789</span>}</div>
<div class="line"><a id="l01790" name="l01790"></a><span class="lineno"> 1790</span> </div>
<div class="line"><a id="l01791" name="l01791"></a><span class="lineno"> 1791</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01792" name="l01792"></a><span class="lineno"> 1792</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Blob_container&gt;</div>
<div class="line"><a id="l01793" name="l01793"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aa025a04ef0a19aa2065cab61a2b3a92c"> 1793</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#aa025a04ef0a19aa2065cab61a2b3a92c">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::share_after_split_equally_emit_seq</a></div>
<div class="line"><a id="l01794" name="l01794"></a><span class="lineno"> 1794</span>       (<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> size, <span class="keywordtype">bool</span> headless_pool, Blob_container* out_blobs_ptr, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01795" name="l01795"></a><span class="lineno"> 1795</span>{</div>
<div class="line"><a id="l01796" name="l01796"></a><span class="lineno"> 1796</span>  <span class="comment">// If changing this please see Blob_with_log_context::&lt;same method&gt;().</span></div>
<div class="line"><a id="l01797" name="l01797"></a><span class="lineno"> 1797</span> </div>
<div class="line"><a id="l01798" name="l01798"></a><span class="lineno"> 1798</span>  assert(out_blobs_ptr);</div>
<div class="line"><a id="l01799" name="l01799"></a><span class="lineno"> 1799</span>  share_after_split_equally(size, headless_pool, [&amp;](<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp;&amp; blob_moved)</div>
<div class="line"><a id="l01800" name="l01800"></a><span class="lineno"> 1800</span>  {</div>
<div class="line"><a id="l01801" name="l01801"></a><span class="lineno"> 1801</span>    out_blobs_ptr-&gt;push_back(std::move(blob_moved));</div>
<div class="line"><a id="l01802" name="l01802"></a><span class="lineno"> 1802</span>  }, logger_ptr);</div>
<div class="line"><a id="l01803" name="l01803"></a><span class="lineno"> 1803</span>}</div>
<div class="line"><a id="l01804" name="l01804"></a><span class="lineno"> 1804</span> </div>
<div class="line"><a id="l01805" name="l01805"></a><span class="lineno"> 1805</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01806" name="l01806"></a><span class="lineno"> 1806</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Blob_ptr_container&gt;</div>
<div class="line"><a id="l01807" name="l01807"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#acf07a3d48fd3b216ed2a08a088b7ba6a"> 1807</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#acf07a3d48fd3b216ed2a08a088b7ba6a">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::share_after_split_equally_emit_ptr_seq</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> size,</div>
<div class="line"><a id="l01808" name="l01808"></a><span class="lineno"> 1808</span>                                                                                      <span class="keywordtype">bool</span> headless_pool,</div>
<div class="line"><a id="l01809" name="l01809"></a><span class="lineno"> 1809</span>                                                                                      Blob_ptr_container* out_blobs_ptr,</div>
<div class="line"><a id="l01810" name="l01810"></a><span class="lineno"> 1810</span>                                                                                      <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01811" name="l01811"></a><span class="lineno"> 1811</span>{</div>
<div class="line"><a id="l01812" name="l01812"></a><span class="lineno"> 1812</span>  <span class="comment">// If changing this please see Blob_with_log_context::&lt;same method&gt;().</span></div>
<div class="line"><a id="l01813" name="l01813"></a><span class="lineno"> 1813</span> </div>
<div class="line"><a id="l01814" name="l01814"></a><span class="lineno"> 1814</span>  <span class="comment">// By documented requirements this should be, like, &lt;...&gt;_ptr&lt;Basic_blob&gt;.</span></div>
<div class="line"><a id="l01815" name="l01815"></a><span class="lineno"> 1815</span>  <span class="keyword">using </span>Ptr = <span class="keyword">typename</span> Blob_ptr_container::value_type;</div>
<div class="line"><a id="l01816" name="l01816"></a><span class="lineno"> 1816</span> </div>
<div class="line"><a id="l01817" name="l01817"></a><span class="lineno"> 1817</span>  assert(out_blobs_ptr);</div>
<div class="line"><a id="l01818" name="l01818"></a><span class="lineno"> 1818</span> </div>
<div class="line"><a id="l01819" name="l01819"></a><span class="lineno"> 1819</span>  share_after_split_equally(size, headless_pool, [&amp;](<a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>&amp;&amp; blob_moved)</div>
<div class="line"><a id="l01820" name="l01820"></a><span class="lineno"> 1820</span>  {</div>
<div class="line"><a id="l01821" name="l01821"></a><span class="lineno"> 1821</span>    out_blobs_ptr-&gt;push_back(Ptr(<span class="keyword">new</span> <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>{std::move(blob_moved)}));</div>
<div class="line"><a id="l01822" name="l01822"></a><span class="lineno"> 1822</span>  }, logger_ptr);</div>
<div class="line"><a id="l01823" name="l01823"></a><span class="lineno"> 1823</span>}</div>
<div class="line"><a id="l01824" name="l01824"></a><span class="lineno"> 1824</span> </div>
<div class="line"><a id="l01825" name="l01825"></a><span class="lineno"> 1825</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01826" name="l01826"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#af567381736851969f6e8812c54404028"> 1826</a></span><span class="keywordtype">bool</span> <a class="code hl_function" href="namespaceflow_1_1util.html#af567381736851969f6e8812c54404028">blobs_sharing</a>(<span class="keyword">const</span> <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a>&amp; blob1,</div>
<div class="line"><a id="l01827" name="l01827"></a><span class="lineno"> 1827</span>                   <span class="keyword">const</span> <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;</a>&amp; blob2)</div>
<div class="line"><a id="l01828" name="l01828"></a><span class="lineno"> 1828</span>{</div>
<div class="line"><a id="l01829" name="l01829"></a><span class="lineno"> 1829</span>  <span class="keyword">static_assert</span>(S_SHARING_ALLOWED,</div>
<div class="line"><a id="l01830" name="l01830"></a><span class="lineno"> 1830</span>                <span class="stringliteral">&quot;blobs_sharing() would only make sense on `Basic_blob`s with S_SHARING_ALLOWED=true.  &quot;</span></div>
<div class="line"><a id="l01831" name="l01831"></a><span class="lineno"> 1831</span>                  <span class="stringliteral">&quot;Even if we were to allow this to instantiate (compile) it would always return false.&quot;</span>);</div>
<div class="line"><a id="l01832" name="l01832"></a><span class="lineno"> 1832</span> </div>
<div class="line"><a id="l01833" name="l01833"></a><span class="lineno"> 1833</span>  <span class="keywordflow">return</span> ((!blob1.<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a1a64646d656ec125fa8973ccf843c1be">zero</a>()) &amp;&amp; (!blob2.<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a1a64646d656ec125fa8973ccf843c1be">zero</a>())) <span class="comment">// Can&#39;t co-own a buffer if doesn&#39;t own a buffer.</span></div>
<div class="line"><a id="l01834" name="l01834"></a><span class="lineno"> 1834</span>         &amp;&amp; ((&amp;blob1 == &amp;blob2) <span class="comment">// Same object =&gt; same buffer.</span></div>
<div class="line"><a id="l01835" name="l01835"></a><span class="lineno"> 1835</span>             <span class="comment">// Only share() (as of this writing) can lead to the underlying buffer&#39;s start ptr being identical.</span></div>
<div class="line"><a id="l01836" name="l01836"></a><span class="lineno"> 1836</span>             || ((blob1.<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9daa427a42c8a8c24b585f96c37d277a">begin</a>() - blob1.<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a64ea173065830ef1a744458a7d05b833">start</a>())</div>
<div class="line"><a id="l01837" name="l01837"></a><span class="lineno"> 1837</span>                 == (blob2.<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9daa427a42c8a8c24b585f96c37d277a">begin</a>() - blob2.<a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a64ea173065830ef1a744458a7d05b833">start</a>())));</div>
<div class="line"><a id="l01838" name="l01838"></a><span class="lineno"> 1838</span>  <span class="comment">// @todo Maybe throw in assert(blob1.capacity() == blob2.capacity()), if `true` is being returned.</span></div>
<div class="line"><a id="l01839" name="l01839"></a><span class="lineno"> 1839</span>}</div>
<div class="line"><a id="l01840" name="l01840"></a><span class="lineno"> 1840</span> </div>
<div class="line"><a id="l01841" name="l01841"></a><span class="lineno"> 1841</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01842" name="l01842"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b"> 1842</a></span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::size</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l01843" name="l01843"></a><span class="lineno"> 1843</span><span class="keyword"></span>{</div>
<div class="line"><a id="l01844" name="l01844"></a><span class="lineno"> 1844</span>  <span class="keywordflow">return</span> zero() ? 0 : m_size; <span class="comment">// Note that zero() may or may not be true if we return 0.</span></div>
<div class="line"><a id="l01845" name="l01845"></a><span class="lineno"> 1845</span>}</div>
<div class="line"><a id="l01846" name="l01846"></a><span class="lineno"> 1846</span> </div>
<div class="line"><a id="l01847" name="l01847"></a><span class="lineno"> 1847</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01848" name="l01848"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a64ea173065830ef1a744458a7d05b833"> 1848</a></span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a64ea173065830ef1a744458a7d05b833">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::start</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l01849" name="l01849"></a><span class="lineno"> 1849</span><span class="keyword"></span>{</div>
<div class="line"><a id="l01850" name="l01850"></a><span class="lineno"> 1850</span>  <span class="keywordflow">return</span> zero() ? 0 : m_start; <span class="comment">// Note that zero() may or may not be true if we return 0.</span></div>
<div class="line"><a id="l01851" name="l01851"></a><span class="lineno"> 1851</span>}</div>
<div class="line"><a id="l01852" name="l01852"></a><span class="lineno"> 1852</span> </div>
<div class="line"><a id="l01853" name="l01853"></a><span class="lineno"> 1853</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01854" name="l01854"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a797741a0a5c95b13b36f356ae8d397e8"> 1854</a></span><span class="keywordtype">bool</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a797741a0a5c95b13b36f356ae8d397e8">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::empty</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l01855" name="l01855"></a><span class="lineno"> 1855</span><span class="keyword"></span>{</div>
<div class="line"><a id="l01856" name="l01856"></a><span class="lineno"> 1856</span>  <span class="keywordflow">return</span> size() == 0; <span class="comment">// Note that zero() may or may not be true if we return true.</span></div>
<div class="line"><a id="l01857" name="l01857"></a><span class="lineno"> 1857</span>}</div>
<div class="line"><a id="l01858" name="l01858"></a><span class="lineno"> 1858</span> </div>
<div class="line"><a id="l01859" name="l01859"></a><span class="lineno"> 1859</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01860" name="l01860"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a719e5c04e4bdc65c31976fc385fd7f24"> 1860</a></span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::size_type</a> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a719e5c04e4bdc65c31976fc385fd7f24">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::capacity</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l01861" name="l01861"></a><span class="lineno"> 1861</span><span class="keyword"></span>{</div>
<div class="line"><a id="l01862" name="l01862"></a><span class="lineno"> 1862</span>  <span class="keywordflow">return</span> zero() ? 0 : m_capacity; <span class="comment">// Note that zero() &lt;=&gt; we return non-zero.  (m_capacity &gt;= 1 if !zero().)</span></div>
<div class="line"><a id="l01863" name="l01863"></a><span class="lineno"> 1863</span>}</div>
<div class="line"><a id="l01864" name="l01864"></a><span class="lineno"> 1864</span> </div>
<div class="line"><a id="l01865" name="l01865"></a><span class="lineno"> 1865</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01866" name="l01866"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a1a64646d656ec125fa8973ccf843c1be"> 1866</a></span><span class="keywordtype">bool</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a1a64646d656ec125fa8973ccf843c1be">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::zero</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l01867" name="l01867"></a><span class="lineno"> 1867</span><span class="keyword"></span>{</div>
<div class="line"><a id="l01868" name="l01868"></a><span class="lineno"> 1868</span>  <span class="keywordflow">return</span> !m_buf_ptr;</div>
<div class="line"><a id="l01869" name="l01869"></a><span class="lineno"> 1869</span>}</div>
<div class="line"><a id="l01870" name="l01870"></a><span class="lineno"> 1870</span> </div>
<div class="line"><a id="l01871" name="l01871"></a><span class="lineno"> 1871</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l01872" name="l01872"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aaa7bc2f80b4e46a18f04911954e2b3e7"> 1872</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#aaa7bc2f80b4e46a18f04911954e2b3e7">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::reserve</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> new_capacity, <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l01873" name="l01873"></a><span class="lineno"> 1873</span>{</div>
<div class="line"><a id="l01874" name="l01874"></a><span class="lineno"> 1874</span>  <span class="keyword">using </span>boost::make_shared_noinit;</div>
<div class="line"><a id="l01875" name="l01875"></a><span class="lineno"> 1875</span>  <span class="keyword">using </span>boost::shared_ptr;</div>
<div class="line"><a id="l01876" name="l01876"></a><span class="lineno"> 1876</span>  <span class="keyword">using </span>std::numeric_limits;</div>
<div class="line"><a id="l01877" name="l01877"></a><span class="lineno"> 1877</span> </div>
<div class="line"><a id="l01878" name="l01878"></a><span class="lineno"> 1878</span>  <span class="comment">/* As advertised do not allow enlarging existing buffer.  They can call make_zero() though (but must do so consciously</span></div>
<div class="line"><a id="l01879" name="l01879"></a><span class="lineno"> 1879</span><span class="comment">   * hence considering the performance impact). */</span></div>
<div class="line"><a id="l01880" name="l01880"></a><span class="lineno"> 1880</span>  assert(zero() || ((new_capacity &lt;= m_capacity) &amp;&amp; (m_capacity &gt; 0)));</div>
<div class="line"><a id="l01881" name="l01881"></a><span class="lineno"> 1881</span> </div>
<div class="line"><a id="l01882" name="l01882"></a><span class="lineno"> 1882</span>  <span class="comment">/* OK, but what if new_capacity &lt; m_capacity?  Then post-condition (see below) is already satisfied, and it&#39;s fastest</span></div>
<div class="line"><a id="l01883" name="l01883"></a><span class="lineno"> 1883</span><span class="comment">   * to do nothing.  If user believes lower memory use is higher-priority, they can explicitly call make_zero() first</span></div>
<div class="line"><a id="l01884" name="l01884"></a><span class="lineno"> 1884</span><span class="comment">   * but must make conscious decision to do so. */</span></div>
<div class="line"><a id="l01885" name="l01885"></a><span class="lineno"> 1885</span> </div>
<div class="line"><a id="l01886" name="l01886"></a><span class="lineno"> 1886</span>  <span class="keywordflow">if</span> (zero() &amp;&amp; (new_capacity != 0))</div>
<div class="line"><a id="l01887" name="l01887"></a><span class="lineno"> 1887</span>  {</div>
<div class="line"><a id="l01888" name="l01888"></a><span class="lineno"> 1888</span>    <span class="keywordflow">if</span> (logger_ptr &amp;&amp; logger_ptr-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">log::Sev::S_TRACE</a>, S_LOG_COMPONENT))</div>
<div class="line"><a id="l01889" name="l01889"></a><span class="lineno"> 1889</span>    {</div>
<div class="line"><a id="l01890" name="l01890"></a><span class="lineno"> 1890</span>      <a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(logger_ptr, S_LOG_COMPONENT);</div>
<div class="line"><a id="l01891" name="l01891"></a><span class="lineno"> 1891</span>      <a class="code hl_define" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a>(<span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; <span class="keyword">this</span> &lt;&lt; <span class="stringliteral">&quot;] &quot;</span></div>
<div class="line"><a id="l01892" name="l01892"></a><span class="lineno"> 1892</span>                                      <span class="stringliteral">&quot;allocating internal buffer sized [&quot;</span> &lt;&lt; new_capacity &lt;&lt; <span class="stringliteral">&quot;].&quot;</span>);</div>
<div class="line"><a id="l01893" name="l01893"></a><span class="lineno"> 1893</span>    }</div>
<div class="line"><a id="l01894" name="l01894"></a><span class="lineno"> 1894</span> </div>
<div class="line"><a id="l01895" name="l01895"></a><span class="lineno"> 1895</span>    <span class="keywordflow">if</span> (new_capacity &lt;= <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a>(numeric_limits&lt;std::ptrdiff_t&gt;::max())) <span class="comment">// (See explanation near bottom of method.)</span></div>
<div class="line"><a id="l01896" name="l01896"></a><span class="lineno"> 1896</span>    {</div>
<div class="line"><a id="l01897" name="l01897"></a><span class="lineno"> 1897</span>      <span class="comment">/* Time to (1) allocate the buffer; (2) save the pointer; (3) ensure it is deallocated at the right time</span></div>
<div class="line"><a id="l01898" name="l01898"></a><span class="lineno"> 1898</span><span class="comment">       * and with the right steps.  Due to Allocator_raw support this is a bit more complex than usual.  Please</span></div>
<div class="line"><a id="l01899" name="l01899"></a><span class="lineno"> 1899</span><span class="comment">       * (1) see class doc header &quot;Custom allocator&quot; section; and (2) read Buf_ptr alias doc header for key background;</span></div>
<div class="line"><a id="l01900" name="l01900"></a><span class="lineno"> 1900</span><span class="comment">       * then come back here. */</span></div>
<div class="line"><a id="l01901" name="l01901"></a><span class="lineno"> 1901</span> </div>
<div class="line"><a id="l01902" name="l01902"></a><span class="lineno"> 1902</span>      <span class="keywordflow">if</span> <span class="keyword">constexpr</span>(S_IS_VANILLA_ALLOC)</div>
<div class="line"><a id="l01903" name="l01903"></a><span class="lineno"> 1903</span>      {</div>
<div class="line"><a id="l01904" name="l01904"></a><span class="lineno"> 1904</span>        <span class="comment">/* In this case they specified std::allocator, so we are to just allocate/deallocate in regular heap using</span></div>
<div class="line"><a id="l01905" name="l01905"></a><span class="lineno"> 1905</span><span class="comment">         * new[]/delete[].  Hence we don&#39;t need to even use actual std::allocator; we know by definition it would</span></div>
<div class="line"><a id="l01906" name="l01906"></a><span class="lineno"> 1906</span><span class="comment">         * use new[]/delete[].  So simply use typical ..._ptr initialization.  Caveats are unrelated to allocators:</span></div>
<div class="line"><a id="l01907" name="l01907"></a><span class="lineno"> 1907</span><span class="comment">         *   - For some extra TRACE-logging -- if enabled! -- use an otherwise-vanilla logging deleter.</span></div>
<div class="line"><a id="l01908" name="l01908"></a><span class="lineno"> 1908</span><span class="comment">         *     - Unnecessary in case of unique_ptr: dealloc always occurs in make_zero() or dtor and can be logged</span></div>
<div class="line"><a id="l01909" name="l01909"></a><span class="lineno"> 1909</span><span class="comment">         *       there.</span></div>
<div class="line"><a id="l01910" name="l01910"></a><span class="lineno"> 1910</span><span class="comment">         *   - If doing so (note it implies we&#39;ve given up on performance) we cannot, and do not, use</span></div>
<div class="line"><a id="l01911" name="l01911"></a><span class="lineno"> 1911</span><span class="comment">         *     make_shared*(); the use of custom deleter requires the .reset() form of init. */</span></div>
<div class="line"><a id="l01912" name="l01912"></a><span class="lineno"> 1912</span> </div>
<div class="line"><a id="l01913" name="l01913"></a><span class="lineno"> 1913</span>        <span class="comment">/* If TRACE currently disabled, then skip the custom deleter that logs about dealloc.  (TRACE may be enabled</span></div>
<div class="line"><a id="l01914" name="l01914"></a><span class="lineno"> 1914</span><span class="comment">         * by that point; but, hey, that is life.)  This is for perf. */</span></div>
<div class="line"><a id="l01915" name="l01915"></a><span class="lineno"> 1915</span>        <span class="keywordflow">if</span> <span class="keyword">constexpr</span>(S_SHARING)</div>
<div class="line"><a id="l01916" name="l01916"></a><span class="lineno"> 1916</span>        {</div>
<div class="line"><a id="l01917" name="l01917"></a><span class="lineno"> 1917</span>          <span class="keywordflow">if</span> (logger_ptr &amp;&amp; logger_ptr-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">log::Sev::S_TRACE</a>, S_LOG_COMPONENT))</div>
<div class="line"><a id="l01918" name="l01918"></a><span class="lineno"> 1918</span>          {</div>
<div class="line"><a id="l01919" name="l01919"></a><span class="lineno"> 1919</span>            <span class="comment">/* This ensures delete[] call when m_buf_ptr ref-count reaches 0.</span></div>
<div class="line"><a id="l01920" name="l01920"></a><span class="lineno"> 1920</span><span class="comment">             * As advertised, for performance, the memory is NOT initialized. */</span></div>
<div class="line"><a id="l01921" name="l01921"></a><span class="lineno"> 1921</span>            m_buf_ptr.reset(<span class="keyword">new</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>[new_capacity],</div>
<div class="line"><a id="l01922" name="l01922"></a><span class="lineno"> 1922</span>                            <span class="comment">// Careful!  *this might be gone if some other share()ing obj is the one that 0s ref-count.</span></div>
<div class="line"><a id="l01923" name="l01923"></a><span class="lineno"> 1923</span>                            [logger_ptr, original_blob = <span class="keyword">this</span>, new_capacity]</div>
<div class="line"><a id="l01924" name="l01924"></a><span class="lineno"> 1924</span>                              (<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>* buf_ptr)</div>
<div class="line"><a id="l01925" name="l01925"></a><span class="lineno"> 1925</span>            {</div>
<div class="line"><a id="l01926" name="l01926"></a><span class="lineno"> 1926</span>              <a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(logger_ptr, S_LOG_COMPONENT);</div>
<div class="line"><a id="l01927" name="l01927"></a><span class="lineno"> 1927</span>              <a class="code hl_define" href="log_8hpp.html#affcf2e4c496ce3f42adf981669c623b8">FLOW_LOG_TRACE</a>(<span class="stringliteral">&quot;Deallocating internal buffer sized [&quot;</span> &lt;&lt; new_capacity &lt;&lt; <span class="stringliteral">&quot;] originally allocated by &quot;</span></div>
<div class="line"><a id="l01928" name="l01928"></a><span class="lineno"> 1928</span>                             <span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; original_blob &lt;&lt; <span class="stringliteral">&quot;]; note that Blob may now be gone and furthermore another &quot;</span></div>
<div class="line"><a id="l01929" name="l01929"></a><span class="lineno"> 1929</span>                             <span class="stringliteral">&quot;Blob might live at that address now.  A message immediately preceding this one should &quot;</span></div>
<div class="line"><a id="l01930" name="l01930"></a><span class="lineno"> 1930</span>                             <span class="stringliteral">&quot;indicate the last Blob to give up ownership of the internal buffer.&quot;</span>);</div>
<div class="line"><a id="l01931" name="l01931"></a><span class="lineno"> 1931</span>              <span class="comment">// Finally just do what the default one would&#39;ve done, as we&#39;ve done our custom thing (logging).</span></div>
<div class="line"><a id="l01932" name="l01932"></a><span class="lineno"> 1932</span>              <span class="keyword">delete</span> [] buf_ptr;</div>
<div class="line"><a id="l01933" name="l01933"></a><span class="lineno"> 1933</span>            });</div>
<div class="line"><a id="l01934" name="l01934"></a><span class="lineno"> 1934</span>          }</div>
<div class="line"><a id="l01935" name="l01935"></a><span class="lineno"> 1935</span>          <span class="keywordflow">else</span> <span class="comment">// if (!should_log()): No logging deleter; just delete[] it.</span></div>
<div class="line"><a id="l01936" name="l01936"></a><span class="lineno"> 1936</span>          {</div>
<div class="line"><a id="l01937" name="l01937"></a><span class="lineno"> 1937</span>            <span class="comment">/* This executes `new value_type[new_capacity]` and ensures delete[] when m_buf_ptr ref-count reaches 0.</span></div>
<div class="line"><a id="l01938" name="l01938"></a><span class="lineno"> 1938</span><span class="comment">             * As advertised, for performance, the memory is NOT initialized. */</span></div>
<div class="line"><a id="l01939" name="l01939"></a><span class="lineno"> 1939</span>            m_buf_ptr = make_shared_noinit&lt;value_type[]&gt;(new_capacity);</div>
<div class="line"><a id="l01940" name="l01940"></a><span class="lineno"> 1940</span>          }</div>
<div class="line"><a id="l01941" name="l01941"></a><span class="lineno"> 1941</span>        } <span class="comment">// if constexpr(S_SHARING)</span></div>
<div class="line"><a id="l01942" name="l01942"></a><span class="lineno"> 1942</span>        <span class="keywordflow">else</span> <span class="comment">// if constexpr(!S_SHARING)</span></div>
<div class="line"><a id="l01943" name="l01943"></a><span class="lineno"> 1943</span>        {</div>
<div class="line"><a id="l01944" name="l01944"></a><span class="lineno"> 1944</span>          m_buf_ptr = boost::movelib::make_unique_definit&lt;value_type[]&gt;(new_capacity);</div>
<div class="line"><a id="l01945" name="l01945"></a><span class="lineno"> 1945</span>          <span class="comment">// Again -- the logging in make_zero() (and Blob_with_log_context dtor) is sufficient.</span></div>
<div class="line"><a id="l01946" name="l01946"></a><span class="lineno"> 1946</span>        }</div>
<div class="line"><a id="l01947" name="l01947"></a><span class="lineno"> 1947</span>      } <span class="comment">// if constexpr(S_IS_VANILLA_ALLOC)</span></div>
<div class="line"><a id="l01948" name="l01948"></a><span class="lineno"> 1948</span>      <span class="keywordflow">else</span> <span class="comment">// if constexpr(!S_IS_VANILLA_ALLOC)</span></div>
<div class="line"><a id="l01949" name="l01949"></a><span class="lineno"> 1949</span>      {</div>
<div class="line"><a id="l01950" name="l01950"></a><span class="lineno"> 1950</span>        <span class="comment">/* Fancy (well, potentially) allocator time.  Again, if you&#39;ve read the Buf_ptr and Deleter_raw doc headers,</span></div>
<div class="line"><a id="l01951" name="l01951"></a><span class="lineno"> 1951</span><span class="comment">         * you&#39;ll know what&#39;s going on. */</span></div>
<div class="line"><a id="l01952" name="l01952"></a><span class="lineno"> 1952</span> </div>
<div class="line"><a id="l01953" name="l01953"></a><span class="lineno"> 1953</span>        <span class="keywordflow">if</span> <span class="keyword">constexpr</span>(S_SHARING)</div>
<div class="line"><a id="l01954" name="l01954"></a><span class="lineno"> 1954</span>        {</div>
<div class="line"><a id="l01955" name="l01955"></a><span class="lineno"> 1955</span>          m_buf_ptr.reset(m_alloc_raw.allocate(new_capacity), <span class="comment">// Raw-allocate via Allocator_raw!  No value-init occurs.</span></div>
<div class="line"><a id="l01956" name="l01956"></a><span class="lineno"> 1956</span> </div>
<div class="line"><a id="l01957" name="l01957"></a><span class="lineno"> 1957</span>                          <span class="comment">/* Let them allocate aux data (ref count block) via Allocator_raw::allocate()</span></div>
<div class="line"><a id="l01958" name="l01958"></a><span class="lineno"> 1958</span><span class="comment">                           * (and dealloc it -- ref count block -- via Allocator_raw::deallocate())!</span></div>
<div class="line"><a id="l01959" name="l01959"></a><span class="lineno"> 1959</span><span class="comment">                           * Have them store internal ptr bits as `Allocator_raw::pointer`s, not</span></div>
<div class="line"><a id="l01960" name="l01960"></a><span class="lineno"> 1960</span><span class="comment">                           * necessarily raw `value_type*`s! */</span></div>
<div class="line"><a id="l01961" name="l01961"></a><span class="lineno"> 1961</span>                          m_alloc_raw,</div>
<div class="line"><a id="l01962" name="l01962"></a><span class="lineno"> 1962</span> </div>
<div class="line"><a id="l01963" name="l01963"></a><span class="lineno"> 1963</span>                          <span class="comment">/* When the time comes to dealloc, invoke this guy like: D(&lt;the ptr&gt;)!  It&#39;ll</span></div>
<div class="line"><a id="l01964" name="l01964"></a><span class="lineno"> 1964</span><span class="comment">                           * perform m_alloc_raw.deallocate(&lt;what .allocate() returned&gt;, n).</span></div>
<div class="line"><a id="l01965" name="l01965"></a><span class="lineno"> 1965</span><span class="comment">                           * Since only we happen to know the size of how much we actually allocated, we pass that info</span></div>
<div class="line"><a id="l01966" name="l01966"></a><span class="lineno"> 1966</span><span class="comment">                           * into the Deleter_raw as well, as it needs to know the `n` to pass to</span></div>
<div class="line"><a id="l01967" name="l01967"></a><span class="lineno"> 1967</span><span class="comment">                           * m_alloc_raw.deallocate(p, n). */</span></div>
<div class="line"><a id="l01968" name="l01968"></a><span class="lineno"> 1968</span>                          <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html">Deleter_raw</a>{m_alloc_raw, new_capacity});</div>
<div class="line"><a id="l01969" name="l01969"></a><span class="lineno"> 1969</span>          <span class="comment">/* Note: Unlike the S_IS_VANILLA_ALLOC=true case above, here we omit any attempt to log at the time</span></div>
<div class="line"><a id="l01970" name="l01970"></a><span class="lineno"> 1970</span><span class="comment">           * of dealloc, even if the verbosity is currently set high enough.  It is not practical to achieve:</span></div>
<div class="line"><a id="l01971" name="l01971"></a><span class="lineno"> 1971</span><span class="comment">           * Recall that the assumptions we take for granted when dealing with std::allocator/regular heap</span></div>
<div class="line"><a id="l01972" name="l01972"></a><span class="lineno"> 1972</span><span class="comment">           * may no longer apply when dealing with an arbitrary allocator/potentially SHM-heap.  To be able</span></div>
<div class="line"><a id="l01973" name="l01973"></a><span class="lineno"> 1973</span><span class="comment">           * to log at dealloc time, the Deleter_raw we create would need to store a Logger*.  Sure, we</span></div>
<div class="line"><a id="l01974" name="l01974"></a><span class="lineno"> 1974</span><span class="comment">           * could pass-in logger_ptr and Deleter_raw could store it; but now recall that we do not</span></div>
<div class="line"><a id="l01975" name="l01975"></a><span class="lineno"> 1975</span><span class="comment">           * store a Logger* in `*this` and why: because (see class doc header) doing so does not play well</span></div>
<div class="line"><a id="l01976" name="l01976"></a><span class="lineno"> 1976</span><span class="comment">           * in some custom-allocator situations, particularly when operating in SHM-heap.  That is why</span></div>
<div class="line"><a id="l01977" name="l01977"></a><span class="lineno"> 1977</span><span class="comment">           * we take an optional Logger* as an arg to every possibly-logging API (we can&#39;t guarantee, if</span></div>
<div class="line"><a id="l01978" name="l01978"></a><span class="lineno"> 1978</span><span class="comment">           * S_IS_VANILLA_ALLOC=false, that a Logger* can meaningfully be stored in likely-Allocator-stored *this).</span></div>
<div class="line"><a id="l01979" name="l01979"></a><span class="lineno"> 1979</span><span class="comment">           * For that same reason we cannot pass it to the Deleter_raw functor; m_buf_ptr (whose bits are in</span></div>
<div class="line"><a id="l01980" name="l01980"></a><span class="lineno"> 1980</span><span class="comment">           * *this) will save a copy of that Deleter_raw and hence *this will end up storing the Logger* which</span></div>
<div class="line"><a id="l01981" name="l01981"></a><span class="lineno"> 1981</span><span class="comment">           * (as noted) may be nonsensical.  (With S_IS_VANILLA_ALLOC=true, though, it&#39;s safe to store it; and</span></div>
<div class="line"><a id="l01982" name="l01982"></a><span class="lineno"> 1982</span><span class="comment">           * since deleter would only fire at dealloc time, it doesn&#39;t present a new perf problem -- since TRACE</span></div>
<div class="line"><a id="l01983" name="l01983"></a><span class="lineno"> 1983</span><span class="comment">           * log level alrady concedes bad perf -- which is the 2nd reason (see class doc header) for why</span></div>
<div class="line"><a id="l01984" name="l01984"></a><span class="lineno"> 1984</span><span class="comment">           * we don&#39;t generally record Logger* but rather take it as an arg to each logging API.)</span></div>
<div class="line"><a id="l01985" name="l01985"></a><span class="lineno"> 1985</span><span class="comment">           *</span></div>
<div class="line"><a id="l01986" name="l01986"></a><span class="lineno"> 1986</span><span class="comment">           * Anyway, long story short, we don&#39;t log on dealloc in this case, b/c we can&#39;t, and the worst that&#39;ll</span></div>
<div class="line"><a id="l01987" name="l01987"></a><span class="lineno"> 1987</span><span class="comment">           * happen as a result of that decision is: deallocs won&#39;t be trace-logged when a custom allocator</span></div>
<div class="line"><a id="l01988" name="l01988"></a><span class="lineno"> 1988</span><span class="comment">           * is enabled at compile-time.  That price is okay to pay. */</span></div>
<div class="line"><a id="l01989" name="l01989"></a><span class="lineno"> 1989</span>        } <span class="comment">// if constexpr(S_SHARING)</span></div>
<div class="line"><a id="l01990" name="l01990"></a><span class="lineno"> 1990</span>        <span class="keywordflow">else</span> <span class="comment">// if constexpr(!S_SHARING)</span></div>
<div class="line"><a id="l01991" name="l01991"></a><span class="lineno"> 1991</span>        {</div>
<div class="line"><a id="l01992" name="l01992"></a><span class="lineno"> 1992</span>          <span class="comment">/* Conceptually it&#39;s quite similar to the S_SHARING case where we do shared_ptr::reset() above.</span></div>
<div class="line"><a id="l01993" name="l01993"></a><span class="lineno"> 1993</span><span class="comment">           * However there is an API difference that is subtle yet real (albeit only for stateful Allocator_raw):</span></div>
<div class="line"><a id="l01994" name="l01994"></a><span class="lineno"> 1994</span><span class="comment">           * Current m_alloc_raw was used to allocate *m_buf_ptr, so it must be used also to dealloc it.</span></div>
<div class="line"><a id="l01995" name="l01995"></a><span class="lineno"> 1995</span><span class="comment">           * unique_ptr::reset() does *not* take a new Deleter_raw; hence if we used it (alone) here it would retain</span></div>
<div class="line"><a id="l01996" name="l01996"></a><span class="lineno"> 1996</span><span class="comment">           * the m_alloc from ction time -- and if that does not equal current m_alloc =&gt; trouble in make_zero()</span></div>
<div class="line"><a id="l01997" name="l01997"></a><span class="lineno"> 1997</span><span class="comment">           * or dtor.</span></div>
<div class="line"><a id="l01998" name="l01998"></a><span class="lineno"> 1998</span><span class="comment">           *</span></div>
<div class="line"><a id="l01999" name="l01999"></a><span class="lineno"> 1999</span><span class="comment">           * Anyway, to beat that, we can either manually overwrite get_deleter() (&lt;-- non-const ref);</span></div>
<div class="line"><a id="l02000" name="l02000"></a><span class="lineno"> 2000</span><span class="comment">           * or we can assign via unique_ptr move-ct.  The latter is certainly pithier and prettier,</span></div>
<div class="line"><a id="l02001" name="l02001"></a><span class="lineno"> 2001</span><span class="comment">           * but the former might be a bit faster.  (Caution!  Recall m_buf_ptr is null currently.  If it were not</span></div>
<div class="line"><a id="l02002" name="l02002"></a><span class="lineno"> 2002</span><span class="comment">           * we would need to explicitly nullify it before the get_deleter() assignment.) */</span></div>
<div class="line"><a id="l02003" name="l02003"></a><span class="lineno"> 2003</span>          m_buf_ptr.get_deleter() = <a class="code hl_class" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html">Deleter_raw</a>{m_alloc_raw, new_capacity};</div>
<div class="line"><a id="l02004" name="l02004"></a><span class="lineno"> 2004</span>          m_buf_ptr.reset(m_alloc_raw.allocate(new_capacity));</div>
<div class="line"><a id="l02005" name="l02005"></a><span class="lineno"> 2005</span>        } <span class="comment">// else if constexpr(!S_SHARING)</span></div>
<div class="line"><a id="l02006" name="l02006"></a><span class="lineno"> 2006</span>      } <span class="comment">// else if constexpr(!S_IS_VANILLA_ALLOC)</span></div>
<div class="line"><a id="l02007" name="l02007"></a><span class="lineno"> 2007</span>    } <span class="comment">// if (new_capacity &lt;= numeric_limits&lt;std::ptrdiff_t&gt;::max()) // (See explanation just below.)</span></div>
<div class="line"><a id="l02008" name="l02008"></a><span class="lineno"> 2008</span>    <span class="keywordflow">else</span></div>
<div class="line"><a id="l02009" name="l02009"></a><span class="lineno"> 2009</span>    {</div>
<div class="line"><a id="l02010" name="l02010"></a><span class="lineno"> 2010</span>      assert(<span class="keyword">false</span> &amp;&amp; <span class="stringliteral">&quot;Enormous or corrupt new_capacity?!&quot;</span>);</div>
<div class="line"><a id="l02011" name="l02011"></a><span class="lineno"> 2011</span>    }</div>
<div class="line"><a id="l02012" name="l02012"></a><span class="lineno"> 2012</span>    <span class="comment">/* ^-- Explanation of the strange if/else:</span></div>
<div class="line"><a id="l02013" name="l02013"></a><span class="lineno"> 2013</span><span class="comment">     * In some gcc versions in some build configs, particularly with aggressive auto-inlining optimization,</span></div>
<div class="line"><a id="l02014" name="l02014"></a><span class="lineno"> 2014</span><span class="comment">     * a warning like this can be triggered (observed, as of this writing, only in the movelib::make_unique_definit()</span></div>
<div class="line"><a id="l02015" name="l02015"></a><span class="lineno"> 2015</span><span class="comment">     * branch above, but to be safe we&#39;re covering all the branches with our if/else work-around):</span></div>
<div class="line"><a id="l02016" name="l02016"></a><span class="lineno"> 2016</span><span class="comment">     *   argument 1 value ‘18446744073709551608’ exceeds maximum object size</span></div>
<div class="line"><a id="l02017" name="l02017"></a><span class="lineno"> 2017</span><span class="comment">     *     9223372036854775807 [-Werror=alloc-size-larger-than=]</span></div>
<div class="line"><a id="l02018" name="l02018"></a><span class="lineno"> 2018</span><span class="comment">     * This occurs due to (among other things) inlining from above our frame down into the boost::movelib call</span></div>
<div class="line"><a id="l02019" name="l02019"></a><span class="lineno"> 2019</span><span class="comment">     * we make (and potentially the other allocating calls in the various branches above);</span></div>
<div class="line"><a id="l02020" name="l02020"></a><span class="lineno"> 2020</span><span class="comment">     * plus allegedly the C++ front-end supplying the huge value during the diagnostics pass.</span></div>
<div class="line"><a id="l02021" name="l02021"></a><span class="lineno"> 2021</span><span class="comment">     * No such huge value (which is 0xFFFFFFFFFFFFFFF8) is actually passed-in at run-time nor mentioned anywhere</span></div>
<div class="line"><a id="l02022" name="l02022"></a><span class="lineno"> 2022</span><span class="comment">     * in our code, here or in the unit-test(s) triggering the auto-inlining triggering the warning.  So:</span></div>
<div class="line"><a id="l02023" name="l02023"></a><span class="lineno"> 2023</span><span class="comment">     *</span></div>
<div class="line"><a id="l02024" name="l02024"></a><span class="lineno"> 2024</span><span class="comment">     * The warning is wholly inaccurate.  This situation is known in the gcc issue database; for example</span></div>
<div class="line"><a id="l02025" name="l02025"></a><span class="lineno"> 2025</span><span class="comment">     * see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85783 and related (linked) tickets.</span></div>
<div class="line"><a id="l02026" name="l02026"></a><span class="lineno"> 2026</span><span class="comment">     * The question was how to work around it; I admit that the discussion in that ticket (and friends) at times</span></div>
<div class="line"><a id="l02027" name="l02027"></a><span class="lineno"> 2027</span><span class="comment">     * gets into topics so obscure and gcc-internal as to be indecipherable to me (ygoldfel).</span></div>
<div class="line"><a id="l02028" name="l02028"></a><span class="lineno"> 2028</span><span class="comment">     * Since I don&#39;t seem to be doing anything wrong above (though: @todo *Maybe* it has something to do with</span></div>
<div class="line"><a id="l02029" name="l02029"></a><span class="lineno"> 2029</span><span class="comment">     * lacking `nothrow`? Would need investigation, nothrow could be good anyway...), the top work-arounds would be</span></div>
<div class="line"><a id="l02030" name="l02030"></a><span class="lineno"> 2030</span><span class="comment">     * perhaps: 1, pragma-away the alloc-size-larger-than warning; 2, use a compiler-placating</span></div>
<div class="line"><a id="l02031" name="l02031"></a><span class="lineno"> 2031</span><span class="comment">     * explicit `if (new_capacity &lt; ...limit...)` branch.  (2) was suggested in the above ticket by a</span></div>
<div class="line"><a id="l02032" name="l02032"></a><span class="lineno"> 2032</span><span class="comment">     * gcc person.  Not wanting to give even a tiny bit of perf I attempted the pragma way (1); but at least gcc-13</span></div>
<div class="line"><a id="l02033" name="l02033"></a><span class="lineno"> 2033</span><span class="comment">     * has some bug which makes the pragma get ignored.  So I reverted to (2) by default.</span></div>
<div class="line"><a id="l02034" name="l02034"></a><span class="lineno"> 2034</span><span class="comment">     * @todo Revisit this.  Should skip workaround unless gcc; + possibly solve it some more elegant way; look into the</span></div>
<div class="line"><a id="l02035" name="l02035"></a><span class="lineno"> 2035</span><span class="comment">     * nothrow thing the ticket discussion briefly mentions (but might be irrelevant). */</span></div>
<div class="line"><a id="l02036" name="l02036"></a><span class="lineno"> 2036</span> </div>
<div class="line"><a id="l02037" name="l02037"></a><span class="lineno"> 2037</span>    m_capacity = new_capacity;</div>
<div class="line"><a id="l02038" name="l02038"></a><span class="lineno"> 2038</span>    m_size = 0; <span class="comment">// Went from zero() to !zero(); so m_size went from meaningless to meaningful and must be set.</span></div>
<div class="line"><a id="l02039" name="l02039"></a><span class="lineno"> 2039</span>    m_start = 0; <span class="comment">// Ditto for m_start.</span></div>
<div class="line"><a id="l02040" name="l02040"></a><span class="lineno"> 2040</span> </div>
<div class="line"><a id="l02041" name="l02041"></a><span class="lineno"> 2041</span>    assert(!zero());</div>
<div class="line"><a id="l02042" name="l02042"></a><span class="lineno"> 2042</span>    <span class="comment">// This is the only path (other than swap()) that assigns to m_capacity; note m_capacity &gt;= 1.</span></div>
<div class="line"><a id="l02043" name="l02043"></a><span class="lineno"> 2043</span>  }</div>
<div class="line"><a id="l02044" name="l02044"></a><span class="lineno"> 2044</span>  <span class="comment">/* else { !zero(): Since new_capacity &lt;= m_capacity, m_capacity is already large enough; no change needed.</span></div>
<div class="line"><a id="l02045" name="l02045"></a><span class="lineno"> 2045</span><span class="comment">   *        zero() &amp;&amp; (new_capacity == 0): Since 0-capacity wanted, we can continue being zero(), as that&#39;s enough. } */</span></div>
<div class="line"><a id="l02046" name="l02046"></a><span class="lineno"> 2046</span> </div>
<div class="line"><a id="l02047" name="l02047"></a><span class="lineno"> 2047</span>  assert(capacity() &gt;= new_capacity); <span class="comment">// Promised post-condition.</span></div>
<div class="line"><a id="l02048" name="l02048"></a><span class="lineno"> 2048</span>} <span class="comment">// Basic_blob::reserve()</span></div>
<div class="line"><a id="l02049" name="l02049"></a><span class="lineno"> 2049</span> </div>
<div class="line"><a id="l02050" name="l02050"></a><span class="lineno"> 2050</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02051" name="l02051"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a30b8db540e6d8e6a0b6200c17cf45b60"> 2051</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a30b8db540e6d8e6a0b6200c17cf45b60">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::resize</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> new_size, <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> new_start_or_unchanged,</div>
<div class="line"><a id="l02052" name="l02052"></a><span class="lineno"> 2052</span>                                                      <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l02053" name="l02053"></a><span class="lineno"> 2053</span>{</div>
<div class="line"><a id="l02054" name="l02054"></a><span class="lineno"> 2054</span>  <span class="keyword">auto</span>&amp; new_start = new_start_or_unchanged;</div>
<div class="line"><a id="l02055" name="l02055"></a><span class="lineno"> 2055</span>  <span class="keywordflow">if</span> (new_start == S_UNCHANGED)</div>
<div class="line"><a id="l02056" name="l02056"></a><span class="lineno"> 2056</span>  {</div>
<div class="line"><a id="l02057" name="l02057"></a><span class="lineno"> 2057</span>    new_start = start();</div>
<div class="line"><a id="l02058" name="l02058"></a><span class="lineno"> 2058</span>  }</div>
<div class="line"><a id="l02059" name="l02059"></a><span class="lineno"> 2059</span> </div>
<div class="line"><a id="l02060" name="l02060"></a><span class="lineno"> 2060</span>  <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> min_capacity = new_start + new_size;</div>
<div class="line"><a id="l02061" name="l02061"></a><span class="lineno"> 2061</span> </div>
<div class="line"><a id="l02062" name="l02062"></a><span class="lineno"> 2062</span>  <span class="comment">// Sanity checks/input checks (depending on how you look at it).</span></div>
<div class="line"><a id="l02063" name="l02063"></a><span class="lineno"> 2063</span>  assert(min_capacity &gt;= new_size);</div>
<div class="line"><a id="l02064" name="l02064"></a><span class="lineno"> 2064</span>  assert(min_capacity &gt;= new_start);</div>
<div class="line"><a id="l02065" name="l02065"></a><span class="lineno"> 2065</span> </div>
<div class="line"><a id="l02066" name="l02066"></a><span class="lineno"> 2066</span>  <span class="comment">/* Ensure there is enough space for new_size starting at new_start.  Note, in particular, this disallows</span></div>
<div class="line"><a id="l02067" name="l02067"></a><span class="lineno"> 2067</span><span class="comment">   * enlarging non-zero() buffer.</span></div>
<div class="line"><a id="l02068" name="l02068"></a><span class="lineno"> 2068</span><span class="comment">   * (If they want, they can explicitly call make_zero() first.  But they must do so consciously, so that they&#39;re</span></div>
<div class="line"><a id="l02069" name="l02069"></a><span class="lineno"> 2069</span><span class="comment">   * forced to consider the performance impact of such an action.)  Also note that zero() continues to be true</span></div>
<div class="line"><a id="l02070" name="l02070"></a><span class="lineno"> 2070</span><span class="comment">   * if was true. */</span></div>
<div class="line"><a id="l02071" name="l02071"></a><span class="lineno"> 2071</span>  reserve(min_capacity, logger_ptr);</div>
<div class="line"><a id="l02072" name="l02072"></a><span class="lineno"> 2072</span>  assert(capacity() &gt;= min_capacity);</div>
<div class="line"><a id="l02073" name="l02073"></a><span class="lineno"> 2073</span> </div>
<div class="line"><a id="l02074" name="l02074"></a><span class="lineno"> 2074</span>  <span class="keywordflow">if</span> (!zero())</div>
<div class="line"><a id="l02075" name="l02075"></a><span class="lineno"> 2075</span>  {</div>
<div class="line"><a id="l02076" name="l02076"></a><span class="lineno"> 2076</span>    m_size = new_size;</div>
<div class="line"><a id="l02077" name="l02077"></a><span class="lineno"> 2077</span>    m_start = new_start;</div>
<div class="line"><a id="l02078" name="l02078"></a><span class="lineno"> 2078</span>  }</div>
<div class="line"><a id="l02079" name="l02079"></a><span class="lineno"> 2079</span>  <span class="comment">// else { zero(): m_size is meaningless; size() == 0, as desired. }</span></div>
<div class="line"><a id="l02080" name="l02080"></a><span class="lineno"> 2080</span> </div>
<div class="line"><a id="l02081" name="l02081"></a><span class="lineno"> 2081</span>  assert(size() == new_size);</div>
<div class="line"><a id="l02082" name="l02082"></a><span class="lineno"> 2082</span>  assert(start() == new_start);</div>
<div class="line"><a id="l02083" name="l02083"></a><span class="lineno"> 2083</span>} <span class="comment">// Basic_blob::resize()</span></div>
<div class="line"><a id="l02084" name="l02084"></a><span class="lineno"> 2084</span> </div>
<div class="line"><a id="l02085" name="l02085"></a><span class="lineno"> 2085</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02086" name="l02086"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#af98832169c8e46d84f6c06987a3670e3"> 2086</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#af98832169c8e46d84f6c06987a3670e3">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::start_past_prefix</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> prefix_size)</div>
<div class="line"><a id="l02087" name="l02087"></a><span class="lineno"> 2087</span>{</div>
<div class="line"><a id="l02088" name="l02088"></a><span class="lineno"> 2088</span>  resize(((start() + size()) &gt; prefix_size)</div>
<div class="line"><a id="l02089" name="l02089"></a><span class="lineno"> 2089</span>           ? (start() + size() - prefix_size)</div>
<div class="line"><a id="l02090" name="l02090"></a><span class="lineno"> 2090</span>           : 0,</div>
<div class="line"><a id="l02091" name="l02091"></a><span class="lineno"> 2091</span>         prefix_size); <span class="comment">// It won&#39;t log, as it cannot allocate, so no need to pass-through a Logger*.</span></div>
<div class="line"><a id="l02092" name="l02092"></a><span class="lineno"> 2092</span>  <span class="comment">// Sanity check: `prefix_size == 0` translates to: resize(start() + size(), 0), as advertised.</span></div>
<div class="line"><a id="l02093" name="l02093"></a><span class="lineno"> 2093</span>}</div>
<div class="line"><a id="l02094" name="l02094"></a><span class="lineno"> 2094</span> </div>
<div class="line"><a id="l02095" name="l02095"></a><span class="lineno"> 2095</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02096" name="l02096"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a9c3497d662be650e7a560eb7a703acc1"> 2096</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9c3497d662be650e7a560eb7a703acc1">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::start_past_prefix_inc</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a614d9cd750d8db928b4d1e045ef15c56">difference_type</a> prefix_size_inc)</div>
<div class="line"><a id="l02097" name="l02097"></a><span class="lineno"> 2097</span>{</div>
<div class="line"><a id="l02098" name="l02098"></a><span class="lineno"> 2098</span>  assert((prefix_size_inc &gt;= 0) || (start() &gt;= <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a>(-prefix_size_inc)));</div>
<div class="line"><a id="l02099" name="l02099"></a><span class="lineno"> 2099</span>  start_past_prefix(start() + prefix_size_inc);</div>
<div class="line"><a id="l02100" name="l02100"></a><span class="lineno"> 2100</span>}</div>
<div class="line"><a id="l02101" name="l02101"></a><span class="lineno"> 2101</span> </div>
<div class="line"><a id="l02102" name="l02102"></a><span class="lineno"> 2102</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02103" name="l02103"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a62da4400fbde6c186fb989f55248e3d2"> 2103</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a62da4400fbde6c186fb989f55248e3d2">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::clear</a>()</div>
<div class="line"><a id="l02104" name="l02104"></a><span class="lineno"> 2104</span>{</div>
<div class="line"><a id="l02105" name="l02105"></a><span class="lineno"> 2105</span>  <span class="comment">// Note: start() remains unchanged (as advertised).  resize(0, 0) can be used if that is unacceptable.</span></div>
<div class="line"><a id="l02106" name="l02106"></a><span class="lineno"> 2106</span>  resize(0); <span class="comment">// It won&#39;t log, as it cannot allocate, so no need to pass-through a Logger*.</span></div>
<div class="line"><a id="l02107" name="l02107"></a><span class="lineno"> 2107</span>  <span class="comment">// Note corner case: zero() remains true if was true (and false if was false).</span></div>
<div class="line"><a id="l02108" name="l02108"></a><span class="lineno"> 2108</span>}</div>
<div class="line"><a id="l02109" name="l02109"></a><span class="lineno"> 2109</span> </div>
<div class="line"><a id="l02110" name="l02110"></a><span class="lineno"> 2110</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02111" name="l02111"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#acf4d5acf2bdde5e602dd2f9d305adebf"> 2111</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#acf4d5acf2bdde5e602dd2f9d305adebf">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::make_zero</a>(<a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l02112" name="l02112"></a><span class="lineno"> 2112</span>{</div>
<div class="line"><a id="l02113" name="l02113"></a><span class="lineno"> 2113</span>  <span class="comment">/* Could also write more elegantly: `swap(Basic_blob());`, but following is a bit optimized (while equivalent);</span></div>
<div class="line"><a id="l02114" name="l02114"></a><span class="lineno"> 2114</span><span class="comment">   * logs better. */</span></div>
<div class="line"><a id="l02115" name="l02115"></a><span class="lineno"> 2115</span>  <span class="keywordflow">if</span> (!zero())</div>
<div class="line"><a id="l02116" name="l02116"></a><span class="lineno"> 2116</span>  {</div>
<div class="line"><a id="l02117" name="l02117"></a><span class="lineno"> 2117</span>    <span class="keywordflow">if</span> (logger_ptr &amp;&amp; logger_ptr-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">log::Sev::S_TRACE</a>, S_LOG_COMPONENT))</div>
<div class="line"><a id="l02118" name="l02118"></a><span class="lineno"> 2118</span>    {</div>
<div class="line"><a id="l02119" name="l02119"></a><span class="lineno"> 2119</span>      <a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(logger_ptr, S_LOG_COMPONENT);</div>
<div class="line"><a id="l02120" name="l02120"></a><span class="lineno"> 2120</span>      <span class="keywordflow">if</span> <span class="keyword">constexpr</span>(S_SHARING_ALLOWED)</div>
<div class="line"><a id="l02121" name="l02121"></a><span class="lineno"> 2121</span>      {</div>
<div class="line"><a id="l02122" name="l02122"></a><span class="lineno"> 2122</span>        <a class="code hl_define" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a>(<span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; <span class="keyword">this</span> &lt;&lt; <span class="stringliteral">&quot;] giving up ownership of internal buffer sized &quot;</span></div>
<div class="line"><a id="l02123" name="l02123"></a><span class="lineno"> 2123</span>                                        <span class="stringliteral">&quot;[&quot;</span> &lt;&lt; capacity() &lt;&lt; <span class="stringliteral">&quot;]; deallocation will immediately follow if no sharing &quot;</span></div>
<div class="line"><a id="l02124" name="l02124"></a><span class="lineno"> 2124</span>                                        <span class="stringliteral">&quot;`Blob`s remain; else ref-count merely decremented.&quot;</span>);</div>
<div class="line"><a id="l02125" name="l02125"></a><span class="lineno"> 2125</span>      }</div>
<div class="line"><a id="l02126" name="l02126"></a><span class="lineno"> 2126</span>      <span class="keywordflow">else</span></div>
<div class="line"><a id="l02127" name="l02127"></a><span class="lineno"> 2127</span>      {</div>
<div class="line"><a id="l02128" name="l02128"></a><span class="lineno"> 2128</span>        <a class="code hl_define" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a>(<span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; <span class="keyword">this</span> &lt;&lt; <span class="stringliteral">&quot;] deallocating internal buffer sized &quot;</span></div>
<div class="line"><a id="l02129" name="l02129"></a><span class="lineno"> 2129</span>                                        <span class="stringliteral">&quot;[&quot;</span> &lt;&lt; capacity() &lt;&lt; <span class="stringliteral">&quot;].&quot;</span>);</div>
<div class="line"><a id="l02130" name="l02130"></a><span class="lineno"> 2130</span>      }</div>
<div class="line"><a id="l02131" name="l02131"></a><span class="lineno"> 2131</span>    }</div>
<div class="line"><a id="l02132" name="l02132"></a><span class="lineno"> 2132</span> </div>
<div class="line"><a id="l02133" name="l02133"></a><span class="lineno"> 2133</span>    m_buf_ptr.reset();</div>
<div class="line"><a id="l02134" name="l02134"></a><span class="lineno"> 2134</span>  } <span class="comment">// if (!zero())</span></div>
<div class="line"><a id="l02135" name="l02135"></a><span class="lineno"> 2135</span>} <span class="comment">// Basic_blob::make_zero()</span></div>
<div class="line"><a id="l02136" name="l02136"></a><span class="lineno"> 2136</span> </div>
<div class="line"><a id="l02137" name="l02137"></a><span class="lineno"> 2137</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02138" name="l02138"></a><span class="lineno"> 2138</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::size_type</a></div>
<div class="line"><a id="l02139" name="l02139"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a4939ea2f0c76ec448cdc12275ce17f33"> 2139</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a4939ea2f0c76ec448cdc12275ce17f33">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::assign_copy</a>(<span class="keyword">const</span> boost::asio::const_buffer&amp; src,</div>
<div class="line"><a id="l02140" name="l02140"></a><span class="lineno"> 2140</span>                                                        <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l02141" name="l02141"></a><span class="lineno"> 2141</span>{</div>
<div class="line"><a id="l02142" name="l02142"></a><span class="lineno"> 2142</span>  <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> n = src.size();</div>
<div class="line"><a id="l02143" name="l02143"></a><span class="lineno"> 2143</span> </div>
<div class="line"><a id="l02144" name="l02144"></a><span class="lineno"> 2144</span>  <span class="comment">/* Either just set m_start = 0 and decrease/keep-constant (m_start + m_size) = n; or allocate exactly n-sized buffer</span></div>
<div class="line"><a id="l02145" name="l02145"></a><span class="lineno"> 2145</span><span class="comment">   * and set m_start = 0, m_size = n.</span></div>
<div class="line"><a id="l02146" name="l02146"></a><span class="lineno"> 2146</span><span class="comment">   * As elsewhere, the latter case requires that zero() be true currently (but they can force that with make_zero()). */</span></div>
<div class="line"><a id="l02147" name="l02147"></a><span class="lineno"> 2147</span>  resize(n, 0); <span class="comment">// It won&#39;t log, as it cannot allocate, so no need to pass-through a Logger*.</span></div>
<div class="line"><a id="l02148" name="l02148"></a><span class="lineno"> 2148</span> </div>
<div class="line"><a id="l02149" name="l02149"></a><span class="lineno"> 2149</span>  <span class="comment">// Performance: Basically equals: memcpy(m_buf_ptr, src.start, src.size).</span></div>
<div class="line"><a id="l02150" name="l02150"></a><span class="lineno"> 2150</span>  emplace_copy(const_begin(), src, logger_ptr);</div>
<div class="line"><a id="l02151" name="l02151"></a><span class="lineno"> 2151</span> </div>
<div class="line"><a id="l02152" name="l02152"></a><span class="lineno"> 2152</span>  <span class="comment">// Corner case: n == 0.  Above is equivalent to: if (!zero()) { m_size = m_start = 0; }.  That behavior is advertised.</span></div>
<div class="line"><a id="l02153" name="l02153"></a><span class="lineno"> 2153</span> </div>
<div class="line"><a id="l02154" name="l02154"></a><span class="lineno"> 2154</span>  <span class="keywordflow">return</span> n;</div>
<div class="line"><a id="l02155" name="l02155"></a><span class="lineno"> 2155</span>}</div>
<div class="line"><a id="l02156" name="l02156"></a><span class="lineno"> 2156</span> </div>
<div class="line"><a id="l02157" name="l02157"></a><span class="lineno"> 2157</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02158" name="l02158"></a><span class="lineno"> 2158</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Iterator</a></div>
<div class="line"><a id="l02159" name="l02159"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a9113cfc8160e93a0e0fa45de8058b858"> 2159</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9113cfc8160e93a0e0fa45de8058b858">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::emplace_copy</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> dest, <span class="keyword">const</span> boost::asio::const_buffer&amp; src,</div>
<div class="line"><a id="l02160" name="l02160"></a><span class="lineno"> 2160</span>                                                         <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)</div>
<div class="line"><a id="l02161" name="l02161"></a><span class="lineno"> 2161</span>{</div>
<div class="line"><a id="l02162" name="l02162"></a><span class="lineno"> 2162</span>  <span class="keyword">using </span>std::memcpy;</div>
<div class="line"><a id="l02163" name="l02163"></a><span class="lineno"> 2163</span> </div>
<div class="line"><a id="l02164" name="l02164"></a><span class="lineno"> 2164</span>  <span class="comment">// Performance: assert()s eliminated and values inlined, below boils down to: memcpy(dest, src.start, src.size);</span></div>
<div class="line"><a id="l02165" name="l02165"></a><span class="lineno"> 2165</span> </div>
<div class="line"><a id="l02166" name="l02166"></a><span class="lineno"> 2166</span>  assert(valid_iterator(dest));</div>
<div class="line"><a id="l02167" name="l02167"></a><span class="lineno"> 2167</span> </div>
<div class="line"><a id="l02168" name="l02168"></a><span class="lineno"> 2168</span>  <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a> dest_it = iterator_sans_const(dest);</div>
<div class="line"><a id="l02169" name="l02169"></a><span class="lineno"> 2169</span>  <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> n = src.size(); <span class="comment">// Note the entire source buffer is copied over.</span></div>
<div class="line"><a id="l02170" name="l02170"></a><span class="lineno"> 2170</span> </div>
<div class="line"><a id="l02171" name="l02171"></a><span class="lineno"> 2171</span>  <span class="keywordflow">if</span> (n != 0)</div>
<div class="line"><a id="l02172" name="l02172"></a><span class="lineno"> 2172</span>  {</div>
<div class="line"><a id="l02173" name="l02173"></a><span class="lineno"> 2173</span>    <span class="keyword">const</span> <span class="keyword">auto</span> src_data = <span class="keyword">static_cast&lt;</span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a><span class="keyword">&gt;</span>(src.data());</div>
<div class="line"><a id="l02174" name="l02174"></a><span class="lineno"> 2174</span> </div>
<div class="line"><a id="l02175" name="l02175"></a><span class="lineno"> 2175</span>    <span class="keywordflow">if</span> (logger_ptr &amp;&amp; logger_ptr-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">log::Sev::S_TRACE</a>, S_LOG_COMPONENT))</div>
<div class="line"><a id="l02176" name="l02176"></a><span class="lineno"> 2176</span>    {</div>
<div class="line"><a id="l02177" name="l02177"></a><span class="lineno"> 2177</span>      <a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(logger_ptr, S_LOG_COMPONENT);</div>
<div class="line"><a id="l02178" name="l02178"></a><span class="lineno"> 2178</span>      <a class="code hl_define" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a>(<span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; <span class="keyword">this</span> &lt;&lt; <span class="stringliteral">&quot;] copying &quot;</span></div>
<div class="line"><a id="l02179" name="l02179"></a><span class="lineno"> 2179</span>                                      <span class="stringliteral">&quot;memory area [&quot;</span> &lt;&lt; <span class="keyword">static_cast&lt;</span><span class="keyword">const </span><span class="keywordtype">void</span>*<span class="keyword">&gt;</span>(src_data) &lt;&lt; <span class="stringliteral">&quot;] sized &quot;</span></div>
<div class="line"><a id="l02180" name="l02180"></a><span class="lineno"> 2180</span>                                      <span class="stringliteral">&quot;[&quot;</span> &lt;&lt; n &lt;&lt; <span class="stringliteral">&quot;] to internal buffer at offset [&quot;</span> &lt;&lt; (dest - const_begin()) &lt;&lt; <span class="stringliteral">&quot;].&quot;</span>);</div>
<div class="line"><a id="l02181" name="l02181"></a><span class="lineno"> 2181</span>    }</div>
<div class="line"><a id="l02182" name="l02182"></a><span class="lineno"> 2182</span> </div>
<div class="line"><a id="l02183" name="l02183"></a><span class="lineno"> 2183</span>    assert(derefable_iterator(dest_it)); <span class="comment">// Input check.</span></div>
<div class="line"><a id="l02184" name="l02184"></a><span class="lineno"> 2184</span>    assert(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a614d9cd750d8db928b4d1e045ef15c56">difference_type</a>(n) &lt;= (const_end() - dest)); <span class="comment">// Input check.  (As advertised, we don&#39;t &quot;correct&quot; `n`.)</span></div>
<div class="line"><a id="l02185" name="l02185"></a><span class="lineno"> 2185</span> </div>
<div class="line"><a id="l02186" name="l02186"></a><span class="lineno"> 2186</span>    <span class="comment">// Ensure no overlap by user.</span></div>
<div class="line"><a id="l02187" name="l02187"></a><span class="lineno"> 2187</span>    assert(((dest_it + n) &lt;= src_data) || ((src_data + n) &lt;= dest_it));</div>
<div class="line"><a id="l02188" name="l02188"></a><span class="lineno"> 2188</span> </div>
<div class="line"><a id="l02189" name="l02189"></a><span class="lineno"> 2189</span>    <span class="comment">/* Some compilers in some build configs issue stringop-overflow warning here, when optimizer heavily auto-inlines:</span></div>
<div class="line"><a id="l02190" name="l02190"></a><span class="lineno"> 2190</span><span class="comment">     *   error: ‘memcpy’ specified bound between 9223372036854775808 and 18446744073709551615</span></div>
<div class="line"><a id="l02191" name="l02191"></a><span class="lineno"> 2191</span><span class="comment">     *     exceeds maximum object size 9223372036854775807 [-Werror=stringop-overflow=]</span></div>
<div class="line"><a id="l02192" name="l02192"></a><span class="lineno"> 2192</span><span class="comment">     * This occurs due to (among other things) inlining from above our frame down into the std::memcpy() call</span></div>
<div class="line"><a id="l02193" name="l02193"></a><span class="lineno"> 2193</span><span class="comment">     * we make; plus allegedly the C++ front-end supplying the huge values during the diagnostics pass.</span></div>
<div class="line"><a id="l02194" name="l02194"></a><span class="lineno"> 2194</span><span class="comment">     * No such huge values (which are 0x800000000000000F, 0xFFFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, respectively)</span></div>
<div class="line"><a id="l02195" name="l02195"></a><span class="lineno"> 2195</span><span class="comment">     * are actually passed-in at run-time nor mentioned anywhere</span></div>
<div class="line"><a id="l02196" name="l02196"></a><span class="lineno"> 2196</span><span class="comment">     * in our code, here or in the unit-test(s) triggering the auto-inlining triggering the warning.  So:</span></div>
<div class="line"><a id="l02197" name="l02197"></a><span class="lineno"> 2197</span><span class="comment">     *</span></div>
<div class="line"><a id="l02198" name="l02198"></a><span class="lineno"> 2198</span><span class="comment">     * The warning is wholly inaccurate in a way reminiscent of the situation in reserve() with a somewhat</span></div>
<div class="line"><a id="l02199" name="l02199"></a><span class="lineno"> 2199</span><span class="comment">     * similar comment.  In this case, however, a pragma does properly work, so we use that approach instead of</span></div>
<div class="line"><a id="l02200" name="l02200"></a><span class="lineno"> 2200</span><span class="comment">     * a run-time check/assert() which would give away a bit of perf. */</span></div>
<div class="line"><a id="l02201" name="l02201"></a><span class="lineno"> 2201</span><span class="preprocessor">#pragma GCC diagnostic push</span></div>
<div class="line"><a id="l02202" name="l02202"></a><span class="lineno"> 2202</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wpragmas&quot;</span> <span class="comment">// For older versions, where the following does not exist/cannot be disabled.</span></div>
<div class="line"><a id="l02203" name="l02203"></a><span class="lineno"> 2203</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wunknown-warning-option&quot;</span> <span class="comment">// (Similarly for clang.)</span></div>
<div class="line"><a id="l02204" name="l02204"></a><span class="lineno"> 2204</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wstringop-overflow&quot;</span></div>
<div class="line"><a id="l02205" name="l02205"></a><span class="lineno"> 2205</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wrestrict&quot;</span> <span class="comment">// Another similar bogus one pops up after pragma-ing away preceding one.</span></div>
<div class="line"><a id="l02206" name="l02206"></a><span class="lineno"> 2206</span> </div>
<div class="line"><a id="l02207" name="l02207"></a><span class="lineno"> 2207</span>    <span class="comment">/* Likely linear-time in `n` but hopefully optimized.  Could use a C++ construct, but I&#39;ve seen that be slower</span></div>
<div class="line"><a id="l02208" name="l02208"></a><span class="lineno"> 2208</span><span class="comment">     * than a direct memcpy() call in practice, at least in a Linux gcc.  Could use boost.asio buffer_copy(), which</span></div>
<div class="line"><a id="l02209" name="l02209"></a><span class="lineno"> 2209</span><span class="comment">     * as of this writing does do memcpy(), but the following is an absolute guarantee of best performance, so better</span></div>
<div class="line"><a id="l02210" name="l02210"></a><span class="lineno"> 2210</span><span class="comment">     * safe than sorry (hence this whole Basic_blob class&#39;s existence, at least in part). */</span></div>
<div class="line"><a id="l02211" name="l02211"></a><span class="lineno"> 2211</span>    memcpy(dest_it, src_data, n);</div>
<div class="line"><a id="l02212" name="l02212"></a><span class="lineno"> 2212</span> </div>
<div class="line"><a id="l02213" name="l02213"></a><span class="lineno"> 2213</span><span class="preprocessor">#pragma GCC diagnostic pop</span></div>
<div class="line"><a id="l02214" name="l02214"></a><span class="lineno"> 2214</span>  }</div>
<div class="line"><a id="l02215" name="l02215"></a><span class="lineno"> 2215</span> </div>
<div class="line"><a id="l02216" name="l02216"></a><span class="lineno"> 2216</span>  <span class="keywordflow">return</span> dest_it + n;</div>
<div class="line"><a id="l02217" name="l02217"></a><span class="lineno"> 2217</span>} <span class="comment">// Basic_blob::emplace_copy()</span></div>
<div class="line"><a id="l02218" name="l02218"></a><span class="lineno"> 2218</span> </div>
<div class="line"><a id="l02219" name="l02219"></a><span class="lineno"> 2219</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02220" name="l02220"></a><span class="lineno"> 2220</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Const_iterator</a></div>
<div class="line"><a id="l02221" name="l02221"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#aa2484d717fde243f6118ac4b0312df87"> 2221</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#aa2484d717fde243f6118ac4b0312df87">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::sub_copy</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> src, <span class="keyword">const</span> boost::asio::mutable_buffer&amp; dest,</div>
<div class="line"><a id="l02222" name="l02222"></a><span class="lineno"> 2222</span>                                                     <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">log::Logger</a>* logger_ptr)<span class="keyword"> const</span></div>
<div class="line"><a id="l02223" name="l02223"></a><span class="lineno"> 2223</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02224" name="l02224"></a><span class="lineno"> 2224</span>  <span class="comment">// Code similar to emplace_copy().  Therefore keeping comments light.</span></div>
<div class="line"><a id="l02225" name="l02225"></a><span class="lineno"> 2225</span> </div>
<div class="line"><a id="l02226" name="l02226"></a><span class="lineno"> 2226</span>  <span class="keyword">using </span>std::memcpy;</div>
<div class="line"><a id="l02227" name="l02227"></a><span class="lineno"> 2227</span> </div>
<div class="line"><a id="l02228" name="l02228"></a><span class="lineno"> 2228</span>  assert(valid_iterator(src));</div>
<div class="line"><a id="l02229" name="l02229"></a><span class="lineno"> 2229</span> </div>
<div class="line"><a id="l02230" name="l02230"></a><span class="lineno"> 2230</span>  <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> n = dest.size(); <span class="comment">// Note the entire destination buffer is filled.</span></div>
<div class="line"><a id="l02231" name="l02231"></a><span class="lineno"> 2231</span>  <span class="keywordflow">if</span> (n != 0)</div>
<div class="line"><a id="l02232" name="l02232"></a><span class="lineno"> 2232</span>  {</div>
<div class="line"><a id="l02233" name="l02233"></a><span class="lineno"> 2233</span>    <span class="keyword">const</span> <span class="keyword">auto</span> dest_data = <span class="keyword">static_cast&lt;</span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a><span class="keyword">&gt;</span>(dest.data());</div>
<div class="line"><a id="l02234" name="l02234"></a><span class="lineno"> 2234</span> </div>
<div class="line"><a id="l02235" name="l02235"></a><span class="lineno"> 2235</span>    <span class="keywordflow">if</span> (logger_ptr &amp;&amp; logger_ptr-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">log::Sev::S_TRACE</a>, S_LOG_COMPONENT))</div>
<div class="line"><a id="l02236" name="l02236"></a><span class="lineno"> 2236</span>    {</div>
<div class="line"><a id="l02237" name="l02237"></a><span class="lineno"> 2237</span>      <a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(logger_ptr, S_LOG_COMPONENT);</div>
<div class="line"><a id="l02238" name="l02238"></a><span class="lineno"> 2238</span>      <a class="code hl_define" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a>(<span class="stringliteral">&quot;Blob [&quot;</span> &lt;&lt; <span class="keyword">this</span> &lt;&lt; <span class="stringliteral">&quot;] copying to &quot;</span></div>
<div class="line"><a id="l02239" name="l02239"></a><span class="lineno"> 2239</span>                                      <span class="stringliteral">&quot;memory area [&quot;</span> &lt;&lt; <span class="keyword">static_cast&lt;</span><span class="keyword">const </span><span class="keywordtype">void</span>*<span class="keyword">&gt;</span>(dest_data) &lt;&lt; <span class="stringliteral">&quot;] sized &quot;</span></div>
<div class="line"><a id="l02240" name="l02240"></a><span class="lineno"> 2240</span>                                      <span class="stringliteral">&quot;[&quot;</span> &lt;&lt; n &lt;&lt; <span class="stringliteral">&quot;] from internal buffer offset [&quot;</span> &lt;&lt; (src - const_begin()) &lt;&lt; <span class="stringliteral">&quot;].&quot;</span>);</div>
<div class="line"><a id="l02241" name="l02241"></a><span class="lineno"> 2241</span>    }</div>
<div class="line"><a id="l02242" name="l02242"></a><span class="lineno"> 2242</span> </div>
<div class="line"><a id="l02243" name="l02243"></a><span class="lineno"> 2243</span>    assert(derefable_iterator(src));</div>
<div class="line"><a id="l02244" name="l02244"></a><span class="lineno"> 2244</span>    assert(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a614d9cd750d8db928b4d1e045ef15c56">difference_type</a>(n) &lt;= (const_end() - src)); <span class="comment">// Can&#39;t copy from beyond end of *this blob.</span></div>
<div class="line"><a id="l02245" name="l02245"></a><span class="lineno"> 2245</span> </div>
<div class="line"><a id="l02246" name="l02246"></a><span class="lineno"> 2246</span>    assert(((src + n) &lt;= dest_data) || ((dest_data + n) &lt;= src));</div>
<div class="line"><a id="l02247" name="l02247"></a><span class="lineno"> 2247</span> </div>
<div class="line"><a id="l02248" name="l02248"></a><span class="lineno"> 2248</span>    <span class="comment">// See explanation for the pragma in emplace_copy().  While warning not yet observed here, preempting it.</span></div>
<div class="line"><a id="l02249" name="l02249"></a><span class="lineno"> 2249</span><span class="preprocessor">#pragma GCC diagnostic push</span></div>
<div class="line"><a id="l02250" name="l02250"></a><span class="lineno"> 2250</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wpragmas&quot;</span> <span class="comment">// For older versions, where the following does not exist/cannot be disabled.</span></div>
<div class="line"><a id="l02251" name="l02251"></a><span class="lineno"> 2251</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wunknown-warning-option&quot;</span> <span class="comment">// (Similarly for clang.)</span></div>
<div class="line"><a id="l02252" name="l02252"></a><span class="lineno"> 2252</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wstringop-overflow&quot;</span></div>
<div class="line"><a id="l02253" name="l02253"></a><span class="lineno"> 2253</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wrestrict&quot;</span></div>
<div class="line"><a id="l02254" name="l02254"></a><span class="lineno"> 2254</span>    memcpy(dest_data, src, n);</div>
<div class="line"><a id="l02255" name="l02255"></a><span class="lineno"> 2255</span><span class="preprocessor">#pragma GCC diagnostic pop</span></div>
<div class="line"><a id="l02256" name="l02256"></a><span class="lineno"> 2256</span>  }</div>
<div class="line"><a id="l02257" name="l02257"></a><span class="lineno"> 2257</span> </div>
<div class="line"><a id="l02258" name="l02258"></a><span class="lineno"> 2258</span>  <span class="keywordflow">return</span> src + n;</div>
<div class="line"><a id="l02259" name="l02259"></a><span class="lineno"> 2259</span>}</div>
<div class="line"><a id="l02260" name="l02260"></a><span class="lineno"> 2260</span> </div>
<div class="line"><a id="l02261" name="l02261"></a><span class="lineno"> 2261</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02262" name="l02262"></a><span class="lineno"> 2262</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Iterator</a></div>
<div class="line"><a id="l02263" name="l02263"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a49046a070b040ca17ca9062ac291a6dd"> 2263</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a49046a070b040ca17ca9062ac291a6dd">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::erase</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> first, <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> past_last)</div>
<div class="line"><a id="l02264" name="l02264"></a><span class="lineno"> 2264</span>{</div>
<div class="line"><a id="l02265" name="l02265"></a><span class="lineno"> 2265</span>  <span class="keyword">using </span>std::memmove;</div>
<div class="line"><a id="l02266" name="l02266"></a><span class="lineno"> 2266</span> </div>
<div class="line"><a id="l02267" name="l02267"></a><span class="lineno"> 2267</span>  assert(derefable_iterator(first)); <span class="comment">// Input check.</span></div>
<div class="line"><a id="l02268" name="l02268"></a><span class="lineno"> 2268</span>  assert(valid_iterator(past_last)); <span class="comment">// Input check.</span></div>
<div class="line"><a id="l02269" name="l02269"></a><span class="lineno"> 2269</span> </div>
<div class="line"><a id="l02270" name="l02270"></a><span class="lineno"> 2270</span>  <span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Iterator</a> dest = iterator_sans_const(first);</div>
<div class="line"><a id="l02271" name="l02271"></a><span class="lineno"> 2271</span> </div>
<div class="line"><a id="l02272" name="l02272"></a><span class="lineno"> 2272</span>  <span class="keywordflow">if</span> (past_last &gt; first) <span class="comment">// (Note: `past_last &lt; first` allowed, not illegal.)</span></div>
<div class="line"><a id="l02273" name="l02273"></a><span class="lineno"> 2273</span>  {</div>
<div class="line"><a id="l02274" name="l02274"></a><span class="lineno"> 2274</span>    <span class="keyword">const</span> <span class="keyword">auto</span> n_moved = <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a>(const_end() - past_last);</div>
<div class="line"><a id="l02275" name="l02275"></a><span class="lineno"> 2275</span> </div>
<div class="line"><a id="l02276" name="l02276"></a><span class="lineno"> 2276</span>    <span class="keywordflow">if</span> (n_moved != 0)</div>
<div class="line"><a id="l02277" name="l02277"></a><span class="lineno"> 2277</span>    {</div>
<div class="line"><a id="l02278" name="l02278"></a><span class="lineno"> 2278</span>      <span class="comment">// See explanation for the pragma in emplace_copy().  While warning not yet observed here, preempting it.</span></div>
<div class="line"><a id="l02279" name="l02279"></a><span class="lineno"> 2279</span><span class="preprocessor">#pragma GCC diagnostic push</span></div>
<div class="line"><a id="l02280" name="l02280"></a><span class="lineno"> 2280</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wpragmas&quot;</span> <span class="comment">// For older versions, where the following does not exist/cannot be disabled.</span></div>
<div class="line"><a id="l02281" name="l02281"></a><span class="lineno"> 2281</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wunknown-warning-option&quot;</span> <span class="comment">// (Similarly for clang.)</span></div>
<div class="line"><a id="l02282" name="l02282"></a><span class="lineno"> 2282</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wstringop-overflow&quot;</span></div>
<div class="line"><a id="l02283" name="l02283"></a><span class="lineno"> 2283</span><span class="preprocessor">#pragma GCC diagnostic ignored &quot;-Wrestrict&quot;</span></div>
<div class="line"><a id="l02284" name="l02284"></a><span class="lineno"> 2284</span>      memmove(dest, iterator_sans_const(past_last), n_moved); <span class="comment">// Cannot use memcpy() due to possible overlap.</span></div>
<div class="line"><a id="l02285" name="l02285"></a><span class="lineno"> 2285</span><span class="preprocessor">#pragma GCC diagnostic pop</span></div>
<div class="line"><a id="l02286" name="l02286"></a><span class="lineno"> 2286</span>    }</div>
<div class="line"><a id="l02287" name="l02287"></a><span class="lineno"> 2287</span>    <span class="comment">// else { Everything past end() is to be erased: it&#39;s sufficient to just update m_size: }</span></div>
<div class="line"><a id="l02288" name="l02288"></a><span class="lineno"> 2288</span> </div>
<div class="line"><a id="l02289" name="l02289"></a><span class="lineno"> 2289</span>    m_size -= (past_last - first);</div>
<div class="line"><a id="l02290" name="l02290"></a><span class="lineno"> 2290</span>    <span class="comment">// m_capacity does not change, as we advertised minimal operations possible to achieve result.</span></div>
<div class="line"><a id="l02291" name="l02291"></a><span class="lineno"> 2291</span>  } <span class="comment">// if (past_last &gt; first)</span></div>
<div class="line"><a id="l02292" name="l02292"></a><span class="lineno"> 2292</span>  <span class="comment">// else if (past_last &lt;= first) { Nothing to do. }</span></div>
<div class="line"><a id="l02293" name="l02293"></a><span class="lineno"> 2293</span> </div>
<div class="line"><a id="l02294" name="l02294"></a><span class="lineno"> 2294</span>  <span class="keywordflow">return</span> dest;</div>
<div class="line"><a id="l02295" name="l02295"></a><span class="lineno"> 2295</span>} <span class="comment">// Basic_blob::erase()</span></div>
<div class="line"><a id="l02296" name="l02296"></a><span class="lineno"> 2296</span> </div>
<div class="line"><a id="l02297" name="l02297"></a><span class="lineno"> 2297</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02298" name="l02298"></a><span class="lineno"> 2298</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::value_type</a> <span class="keyword">const</span> &amp;</div>
<div class="line"><a id="l02299" name="l02299"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a90859b0e130bef705a2e556ccb27df53"> 2299</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a90859b0e130bef705a2e556ccb27df53">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::const_front</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02300" name="l02300"></a><span class="lineno"> 2300</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02301" name="l02301"></a><span class="lineno"> 2301</span>  assert(!empty());</div>
<div class="line"><a id="l02302" name="l02302"></a><span class="lineno"> 2302</span>  <span class="keywordflow">return</span> *const_begin();</div>
<div class="line"><a id="l02303" name="l02303"></a><span class="lineno"> 2303</span>}</div>
<div class="line"><a id="l02304" name="l02304"></a><span class="lineno"> 2304</span> </div>
<div class="line"><a id="l02305" name="l02305"></a><span class="lineno"> 2305</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02306" name="l02306"></a><span class="lineno"> 2306</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::value_type</a></div>
<div class="line"><a id="l02307" name="l02307"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a7c99b053ce77cd0573d882e194908e49"> 2307</a></span>  <span class="keyword">const</span> &amp; <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a7c99b053ce77cd0573d882e194908e49">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::const_back</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02308" name="l02308"></a><span class="lineno"> 2308</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02309" name="l02309"></a><span class="lineno"> 2309</span>  assert(!empty());</div>
<div class="line"><a id="l02310" name="l02310"></a><span class="lineno"> 2310</span>  <span class="keywordflow">return</span> const_end()[-1];</div>
<div class="line"><a id="l02311" name="l02311"></a><span class="lineno"> 2311</span>}</div>
<div class="line"><a id="l02312" name="l02312"></a><span class="lineno"> 2312</span> </div>
<div class="line"><a id="l02313" name="l02313"></a><span class="lineno"> 2313</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02314" name="l02314"></a><span class="lineno"> 2314</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::value_type</a>&amp;</div>
<div class="line"><a id="l02315" name="l02315"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#abe7ea8c6aa0a7b043129fca8eacaedad"> 2315</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a98a489088e29d5d4b82b0498c8e210f8">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::front</a>()</div>
<div class="line"><a id="l02316" name="l02316"></a><span class="lineno"> 2316</span>{</div>
<div class="line"><a id="l02317" name="l02317"></a><span class="lineno"> 2317</span>  assert(!empty());</div>
<div class="line"><a id="l02318" name="l02318"></a><span class="lineno"> 2318</span>  <span class="keywordflow">return</span> *begin();</div>
<div class="line"><a id="l02319" name="l02319"></a><span class="lineno"> 2319</span>}</div>
<div class="line"><a id="l02320" name="l02320"></a><span class="lineno"> 2320</span> </div>
<div class="line"><a id="l02321" name="l02321"></a><span class="lineno"> 2321</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02322" name="l02322"></a><span class="lineno"> 2322</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::value_type</a>&amp;</div>
<div class="line"><a id="l02323" name="l02323"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a49d05eed39be69ceec235fe3403b16b9"> 2323</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ac10980e7748d8198fe831666254d864d">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::back</a>()</div>
<div class="line"><a id="l02324" name="l02324"></a><span class="lineno"> 2324</span>{</div>
<div class="line"><a id="l02325" name="l02325"></a><span class="lineno"> 2325</span>  assert(!empty());</div>
<div class="line"><a id="l02326" name="l02326"></a><span class="lineno"> 2326</span>  <span class="keywordflow">return</span> end()[-1];</div>
<div class="line"><a id="l02327" name="l02327"></a><span class="lineno"> 2327</span>}</div>
<div class="line"><a id="l02328" name="l02328"></a><span class="lineno"> 2328</span> </div>
<div class="line"><a id="l02329" name="l02329"></a><span class="lineno"> 2329</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02330" name="l02330"></a><span class="lineno"> 2330</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::value_type</a> <span class="keyword">const</span> &amp;</div>
<div class="line"><a id="l02331" name="l02331"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a98a489088e29d5d4b82b0498c8e210f8"> 2331</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a98a489088e29d5d4b82b0498c8e210f8">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::front</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02332" name="l02332"></a><span class="lineno"> 2332</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02333" name="l02333"></a><span class="lineno"> 2333</span>  <span class="keywordflow">return</span> const_front();</div>
<div class="line"><a id="l02334" name="l02334"></a><span class="lineno"> 2334</span>}</div>
<div class="line"><a id="l02335" name="l02335"></a><span class="lineno"> 2335</span> </div>
<div class="line"><a id="l02336" name="l02336"></a><span class="lineno"> 2336</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02337" name="l02337"></a><span class="lineno"> 2337</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::value_type</a> <span class="keyword">const</span> &amp;</div>
<div class="line"><a id="l02338" name="l02338"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ac10980e7748d8198fe831666254d864d"> 2338</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ac10980e7748d8198fe831666254d864d">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::back</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02339" name="l02339"></a><span class="lineno"> 2339</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02340" name="l02340"></a><span class="lineno"> 2340</span>  <span class="keywordflow">return</span> const_back();</div>
<div class="line"><a id="l02341" name="l02341"></a><span class="lineno"> 2341</span>}</div>
<div class="line"><a id="l02342" name="l02342"></a><span class="lineno"> 2342</span> </div>
<div class="line"><a id="l02343" name="l02343"></a><span class="lineno"> 2343</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02344" name="l02344"></a><span class="lineno"> 2344</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Const_iterator</a></div>
<div class="line"><a id="l02345" name="l02345"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ac511ddaa3fb453888524cedba39c36ef"> 2345</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ac511ddaa3fb453888524cedba39c36ef">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::const_begin</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02346" name="l02346"></a><span class="lineno"> 2346</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02347" name="l02347"></a><span class="lineno"> 2347</span>  <span class="keywordflow">return</span> <span class="keyword">const_cast&lt;</span><a class="code hl_class" href="classflow_1_1util_1_1Basic__blob.html">Basic_blob</a>*<span class="keyword">&gt;</span>(<span class="keyword">this</span>)-&gt;begin();</div>
<div class="line"><a id="l02348" name="l02348"></a><span class="lineno"> 2348</span>}</div>
<div class="line"><a id="l02349" name="l02349"></a><span class="lineno"> 2349</span> </div>
<div class="line"><a id="l02350" name="l02350"></a><span class="lineno"> 2350</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02351" name="l02351"></a><span class="lineno"> 2351</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Iterator</a></div>
<div class="line"><a id="l02352" name="l02352"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a9daa427a42c8a8c24b585f96c37d277a"> 2352</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9daa427a42c8a8c24b585f96c37d277a">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::begin</a>()</div>
<div class="line"><a id="l02353" name="l02353"></a><span class="lineno"> 2353</span>{</div>
<div class="line"><a id="l02354" name="l02354"></a><span class="lineno"> 2354</span>  <span class="keywordflow">if</span> (zero())</div>
<div class="line"><a id="l02355" name="l02355"></a><span class="lineno"> 2355</span>  {</div>
<div class="line"><a id="l02356" name="l02356"></a><span class="lineno"> 2356</span>    <span class="keywordflow">return</span> 0;</div>
<div class="line"><a id="l02357" name="l02357"></a><span class="lineno"> 2357</span>  }</div>
<div class="line"><a id="l02358" name="l02358"></a><span class="lineno"> 2358</span>  <span class="comment">// else</span></div>
<div class="line"><a id="l02359" name="l02359"></a><span class="lineno"> 2359</span> </div>
<div class="line"><a id="l02360" name="l02360"></a><span class="lineno"> 2360</span>  <span class="comment">/* m_buf_ptr.get() is value_type* when Buf_ptr = regular shared_ptr; but possibly Some_fancy_ptr&lt;value_type&gt;</span></div>
<div class="line"><a id="l02361" name="l02361"></a><span class="lineno"> 2361</span><span class="comment">   * when Buf_ptr = boost::interprocess::shared_ptr&lt;value_type, Allocator_raw&gt;, namely when</span></div>
<div class="line"><a id="l02362" name="l02362"></a><span class="lineno"> 2362</span><span class="comment">   * Allocator_raw::pointer = Some_fancy_ptr&lt;value_type&gt; and not simply value_type* again.  We need value_type*.</span></div>
<div class="line"><a id="l02363" name="l02363"></a><span class="lineno"> 2363</span><span class="comment">   * Fancy-pointer is not really an officially-defined concept (offset_ptr&lt;&gt; is an example of one).</span></div>
<div class="line"><a id="l02364" name="l02364"></a><span class="lineno"> 2364</span><span class="comment">   * Anyway the following works for both cases, but there are a bunch of different things we could write.</span></div>
<div class="line"><a id="l02365" name="l02365"></a><span class="lineno"> 2365</span><span class="comment">   * Since it&#39;s just this one location where we need to do this, I do not care too much, and the following</span></div>
<div class="line"><a id="l02366" name="l02366"></a><span class="lineno"> 2366</span><span class="comment">   * cheesy thing -- &amp;(*p) -- is OK.</span></div>
<div class="line"><a id="l02367" name="l02367"></a><span class="lineno"> 2367</span><span class="comment">   *</span></div>
<div class="line"><a id="l02368" name="l02368"></a><span class="lineno"> 2368</span><span class="comment">   * @todo In C++20 can replace this with std::to_address().  Or can implement our own (copy cppreference.com impl). */</span></div>
<div class="line"><a id="l02369" name="l02369"></a><span class="lineno"> 2369</span> </div>
<div class="line"><a id="l02370" name="l02370"></a><span class="lineno"> 2370</span>  <span class="keyword">const</span> <span class="keyword">auto</span> raw_or_fancy_buf_ptr = m_buf_ptr.get();</div>
<div class="line"><a id="l02371" name="l02371"></a><span class="lineno"> 2371</span>  <span class="keywordflow">return</span> &amp;(*raw_or_fancy_buf_ptr) + m_start;</div>
<div class="line"><a id="l02372" name="l02372"></a><span class="lineno"> 2372</span>}</div>
<div class="line"><a id="l02373" name="l02373"></a><span class="lineno"> 2373</span> </div>
<div class="line"><a id="l02374" name="l02374"></a><span class="lineno"> 2374</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02375" name="l02375"></a><span class="lineno"> 2375</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Const_iterator</a></div>
<div class="line"><a id="l02376" name="l02376"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ae4f1d8c42aea63ba4f127cb7ed5776d6"> 2376</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ae4f1d8c42aea63ba4f127cb7ed5776d6">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::const_end</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02377" name="l02377"></a><span class="lineno"> 2377</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02378" name="l02378"></a><span class="lineno"> 2378</span>  <span class="keywordflow">return</span> zero() ? const_begin() : (const_begin() + size());</div>
<div class="line"><a id="l02379" name="l02379"></a><span class="lineno"> 2379</span>}</div>
<div class="line"><a id="l02380" name="l02380"></a><span class="lineno"> 2380</span> </div>
<div class="line"><a id="l02381" name="l02381"></a><span class="lineno"> 2381</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02382" name="l02382"></a><span class="lineno"> 2382</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Iterator</a></div>
<div class="line"><a id="l02383" name="l02383"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a61880291749335246f60fde4387f7ad6"> 2383</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a61880291749335246f60fde4387f7ad6">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::end</a>()</div>
<div class="line"><a id="l02384" name="l02384"></a><span class="lineno"> 2384</span>{</div>
<div class="line"><a id="l02385" name="l02385"></a><span class="lineno"> 2385</span>  <span class="keywordflow">return</span> zero() ? begin() : (begin() + size());</div>
<div class="line"><a id="l02386" name="l02386"></a><span class="lineno"> 2386</span>}</div>
<div class="line"><a id="l02387" name="l02387"></a><span class="lineno"> 2387</span> </div>
<div class="line"><a id="l02388" name="l02388"></a><span class="lineno"> 2388</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02389" name="l02389"></a><span class="lineno"> 2389</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Const_iterator</a></div>
<div class="line"><a id="l02390" name="l02390"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a1dfd46fca324a6b80934b9230c2f2bb4"> 2390</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9daa427a42c8a8c24b585f96c37d277a">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::begin</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02391" name="l02391"></a><span class="lineno"> 2391</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02392" name="l02392"></a><span class="lineno"> 2392</span>  <span class="keywordflow">return</span> const_begin();</div>
<div class="line"><a id="l02393" name="l02393"></a><span class="lineno"> 2393</span>}</div>
<div class="line"><a id="l02394" name="l02394"></a><span class="lineno"> 2394</span> </div>
<div class="line"><a id="l02395" name="l02395"></a><span class="lineno"> 2395</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02396" name="l02396"></a><span class="lineno"> 2396</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Const_iterator</a></div>
<div class="line"><a id="l02397" name="l02397"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a669252f9a78f516dfeaf964987078255"> 2397</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a669252f9a78f516dfeaf964987078255">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::cbegin</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02398" name="l02398"></a><span class="lineno"> 2398</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02399" name="l02399"></a><span class="lineno"> 2399</span>  <span class="keywordflow">return</span> const_begin();</div>
<div class="line"><a id="l02400" name="l02400"></a><span class="lineno"> 2400</span>}</div>
<div class="line"><a id="l02401" name="l02401"></a><span class="lineno"> 2401</span> </div>
<div class="line"><a id="l02402" name="l02402"></a><span class="lineno"> 2402</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02403" name="l02403"></a><span class="lineno"> 2403</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Const_iterator</a></div>
<div class="line"><a id="l02404" name="l02404"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a9b61c80d3df1c53583362ec15cdbb0b6"> 2404</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a61880291749335246f60fde4387f7ad6">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::end</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02405" name="l02405"></a><span class="lineno"> 2405</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02406" name="l02406"></a><span class="lineno"> 2406</span>  <span class="keywordflow">return</span> const_end();</div>
<div class="line"><a id="l02407" name="l02407"></a><span class="lineno"> 2407</span>}</div>
<div class="line"><a id="l02408" name="l02408"></a><span class="lineno"> 2408</span> </div>
<div class="line"><a id="l02409" name="l02409"></a><span class="lineno"> 2409</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02410" name="l02410"></a><span class="lineno"> 2410</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Const_iterator</a></div>
<div class="line"><a id="l02411" name="l02411"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#ada9e80920dcc3d51c229db98a9d62ac6"> 2411</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#ada9e80920dcc3d51c229db98a9d62ac6">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::cend</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02412" name="l02412"></a><span class="lineno"> 2412</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02413" name="l02413"></a><span class="lineno"> 2413</span>  <span class="keywordflow">return</span> const_end();</div>
<div class="line"><a id="l02414" name="l02414"></a><span class="lineno"> 2414</span>}</div>
<div class="line"><a id="l02415" name="l02415"></a><span class="lineno"> 2415</span> </div>
<div class="line"><a id="l02416" name="l02416"></a><span class="lineno"> 2416</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02417" name="l02417"></a><span class="lineno"> 2417</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::value_type</a></div>
<div class="line"><a id="l02418" name="l02418"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a75d4c0a1e530596982a3b5d3e0ff91e6"> 2418</a></span>  <span class="keyword">const</span> * <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a75d4c0a1e530596982a3b5d3e0ff91e6">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::const_data</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02419" name="l02419"></a><span class="lineno"> 2419</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02420" name="l02420"></a><span class="lineno"> 2420</span>  <span class="keywordflow">return</span> const_begin();</div>
<div class="line"><a id="l02421" name="l02421"></a><span class="lineno"> 2421</span>}</div>
<div class="line"><a id="l02422" name="l02422"></a><span class="lineno"> 2422</span> </div>
<div class="line"><a id="l02423" name="l02423"></a><span class="lineno"> 2423</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02424" name="l02424"></a><span class="lineno"> 2424</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::value_type</a>*</div>
<div class="line"><a id="l02425" name="l02425"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a4581e779dace3d64fe4098eb0a7dbeb2"> 2425</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a4581e779dace3d64fe4098eb0a7dbeb2">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::data</a>()</div>
<div class="line"><a id="l02426" name="l02426"></a><span class="lineno"> 2426</span>{</div>
<div class="line"><a id="l02427" name="l02427"></a><span class="lineno"> 2427</span>  <span class="keywordflow">return</span> begin();</div>
<div class="line"><a id="l02428" name="l02428"></a><span class="lineno"> 2428</span>}</div>
<div class="line"><a id="l02429" name="l02429"></a><span class="lineno"> 2429</span> </div>
<div class="line"><a id="l02430" name="l02430"></a><span class="lineno"> 2430</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02431" name="l02431"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a73e09b11e0067730db64f1fac7620a04"> 2431</a></span><span class="keywordtype">bool</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a73e09b11e0067730db64f1fac7620a04">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::valid_iterator</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> it)<span class="keyword"> const</span></div>
<div class="line"><a id="l02432" name="l02432"></a><span class="lineno"> 2432</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02433" name="l02433"></a><span class="lineno"> 2433</span>  <span class="keywordflow">return</span> empty() ? (it == const_end())</div>
<div class="line"><a id="l02434" name="l02434"></a><span class="lineno"> 2434</span>                 : <a class="code hl_function" href="namespaceflow_1_1util.html#ab10bc9e8bef148f875aa743fe0852743">in_closed_range</a>(const_begin(), it, const_end());</div>
<div class="line"><a id="l02435" name="l02435"></a><span class="lineno"> 2435</span>}</div>
<div class="line"><a id="l02436" name="l02436"></a><span class="lineno"> 2436</span> </div>
<div class="line"><a id="l02437" name="l02437"></a><span class="lineno"> 2437</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02438" name="l02438"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a198eb271d009f153cae041ba1948e945"> 2438</a></span><span class="keywordtype">bool</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a198eb271d009f153cae041ba1948e945">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::derefable_iterator</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> it)<span class="keyword"> const</span></div>
<div class="line"><a id="l02439" name="l02439"></a><span class="lineno"> 2439</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02440" name="l02440"></a><span class="lineno"> 2440</span>  <span class="keywordflow">return</span> empty() ? false</div>
<div class="line"><a id="l02441" name="l02441"></a><span class="lineno"> 2441</span>                 : <a class="code hl_function" href="namespaceflow_1_1util.html#a024ddda9acb2b66f2a1b35cdb0c016aa">in_closed_open_range</a>(const_begin(), it, const_end());</div>
<div class="line"><a id="l02442" name="l02442"></a><span class="lineno"> 2442</span>}</div>
<div class="line"><a id="l02443" name="l02443"></a><span class="lineno"> 2443</span> </div>
<div class="line"><a id="l02444" name="l02444"></a><span class="lineno"> 2444</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02445" name="l02445"></a><span class="lineno"> 2445</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Iterator</a></div>
<div class="line"><a id="l02446" name="l02446"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a9c8a51530bc17f779215970f3097a1f2"> 2446</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a9c8a51530bc17f779215970f3097a1f2">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::iterator_sans_const</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">Const_iterator</a> it)</div>
<div class="line"><a id="l02447" name="l02447"></a><span class="lineno"> 2447</span>{</div>
<div class="line"><a id="l02448" name="l02448"></a><span class="lineno"> 2448</span>  <span class="keywordflow">return</span> <span class="keyword">const_cast&lt;</span><a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">value_type</a>*<span class="keyword">&gt;</span>(it); <span class="comment">// Can be done without const_cast&lt;&gt; but might as well save some cycles.</span></div>
<div class="line"><a id="l02449" name="l02449"></a><span class="lineno"> 2449</span>}</div>
<div class="line"><a id="l02450" name="l02450"></a><span class="lineno"> 2450</span> </div>
<div class="line"><a id="l02451" name="l02451"></a><span class="lineno"> 2451</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02452" name="l02452"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#afbb4e2420be2f8ca0dc8c4fb70feb8ea"> 2452</a></span>boost::asio::const_buffer <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#afbb4e2420be2f8ca0dc8c4fb70feb8ea">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::const_buffer</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02453" name="l02453"></a><span class="lineno"> 2453</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02454" name="l02454"></a><span class="lineno"> 2454</span>  <span class="keywordflow">return</span> boost::asio::const_buffer{const_data(), size()};</div>
<div class="line"><a id="l02455" name="l02455"></a><span class="lineno"> 2455</span>}</div>
<div class="line"><a id="l02456" name="l02456"></a><span class="lineno"> 2456</span> </div>
<div class="line"><a id="l02457" name="l02457"></a><span class="lineno"> 2457</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02458" name="l02458"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#a2bd3cb0b6b3f304fb6fb771c1b76ec66"> 2458</a></span>boost::asio::mutable_buffer <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#a2bd3cb0b6b3f304fb6fb771c1b76ec66">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::mutable_buffer</a>()</div>
<div class="line"><a id="l02459" name="l02459"></a><span class="lineno"> 2459</span>{</div>
<div class="line"><a id="l02460" name="l02460"></a><span class="lineno"> 2460</span>  <span class="keywordflow">return</span> boost::asio::mutable_buffer{data(), size()};</div>
<div class="line"><a id="l02461" name="l02461"></a><span class="lineno"> 2461</span>}</div>
<div class="line"><a id="l02462" name="l02462"></a><span class="lineno"> 2462</span> </div>
<div class="line"><a id="l02463" name="l02463"></a><span class="lineno"> 2463</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02464" name="l02464"></a><span class="lineno"> 2464</span><span class="keyword">typename</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Allocator_raw</a></div>
<div class="line"><a id="l02465" name="l02465"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob.html#af32359d0bd98f378c7397a7c86e6e66d"> 2465</a></span>  <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob.html#af32359d0bd98f378c7397a7c86e6e66d">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::get_allocator</a>()<span class="keyword"> const</span></div>
<div class="line"><a id="l02466" name="l02466"></a><span class="lineno"> 2466</span><span class="keyword"></span>{</div>
<div class="line"><a id="l02467" name="l02467"></a><span class="lineno"> 2467</span>  <span class="keywordflow">return</span> m_alloc_raw;</div>
<div class="line"><a id="l02468" name="l02468"></a><span class="lineno"> 2468</span>}</div>
<div class="line"><a id="l02469" name="l02469"></a><span class="lineno"> 2469</span> </div>
<div class="line"><a id="l02470" name="l02470"></a><span class="lineno"> 2470</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02471" name="l02471"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a40b06c7484a925fe7550a3437a0ad194"> 2471</a></span><a class="code hl_function" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a145ea5595e461bd93bd6e585a67516e6">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Deleter_raw::Deleter_raw</a>(<span class="keyword">const</span> <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">Allocator_raw</a>&amp; alloc_raw, <a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">size_type</a> buf_sz) :</div>
<div class="line"><a id="l02472" name="l02472"></a><span class="lineno"> 2472</span>  <span class="comment">/* Copy allocator; a stateless allocator should have size 0 (no-op for the processor in that case... except</span></div>
<div class="line"><a id="l02473" name="l02473"></a><span class="lineno"> 2473</span><span class="comment">   * the optional&lt;&gt; registering it has-a-value). */</span></div>
<div class="line"><a id="l02474" name="l02474"></a><span class="lineno"> 2474</span>  m_alloc_raw(std::in_place, alloc_raw),</div>
<div class="line"><a id="l02475" name="l02475"></a><span class="lineno"> 2475</span>  m_buf_sz(buf_sz) <span class="comment">// We store a T*, where T is a trivial-deleter PoD, but we delete an array of Ts: this many.</span></div>
<div class="line"><a id="l02476" name="l02476"></a><span class="lineno"> 2476</span>{</div>
<div class="line"><a id="l02477" name="l02477"></a><span class="lineno"> 2477</span>  <span class="comment">// OK.</span></div>
<div class="line"><a id="l02478" name="l02478"></a><span class="lineno"> 2478</span>}</div>
<div class="line"><a id="l02479" name="l02479"></a><span class="lineno"> 2479</span> </div>
<div class="line"><a id="l02480" name="l02480"></a><span class="lineno"> 2480</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02481" name="l02481"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a145ea5595e461bd93bd6e585a67516e6"> 2481</a></span><a class="code hl_function" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a145ea5595e461bd93bd6e585a67516e6">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Deleter_raw::Deleter_raw</a>() :</div>
<div class="line"><a id="l02482" name="l02482"></a><span class="lineno"> 2482</span>  m_buf_sz(0)</div>
<div class="line"><a id="l02483" name="l02483"></a><span class="lineno"> 2483</span>{</div>
<div class="line"><a id="l02484" name="l02484"></a><span class="lineno"> 2484</span>  <span class="comment">/* This ctor is never invoked (see this ctor&#39;s doc header).  It can be left `= default;`, but some gcc versions</span></div>
<div class="line"><a id="l02485" name="l02485"></a><span class="lineno"> 2485</span><span class="comment">   * then complain m_buf_sz may be used uninitialized (not true but such is life). */</span></div>
<div class="line"><a id="l02486" name="l02486"></a><span class="lineno"> 2486</span>}</div>
<div class="line"><a id="l02487" name="l02487"></a><span class="lineno"> 2487</span> </div>
<div class="line"><a id="l02488" name="l02488"></a><span class="lineno"> 2488</span><span class="keyword">template</span>&lt;<span class="keyword">typename</span> Allocator, <span class="keywordtype">bool</span> S_SHARING_ALLOWED&gt;</div>
<div class="line"><a id="l02489" name="l02489"></a><span class="lineno"><a class="line" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a83887b57f8a78c0224fd7563210e94ec"> 2489</a></span><span class="keywordtype">void</span> <a class="code hl_function" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a83887b57f8a78c0224fd7563210e94ec">Basic_blob&lt;Allocator, S_SHARING_ALLOWED&gt;::Deleter_raw::operator()</a>(<a class="code hl_typedef" href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#ad45a273758a0fc0bd81ab36edc9d8217">Pointer_raw</a> to_delete)</div>
<div class="line"><a id="l02490" name="l02490"></a><span class="lineno"> 2490</span>{</div>
<div class="line"><a id="l02491" name="l02491"></a><span class="lineno"> 2491</span>  <span class="comment">// No need to invoke dtor: Allocator_raw::value_type is Basic_blob::value_type, a boring int type with no real dtor.</span></div>
<div class="line"><a id="l02492" name="l02492"></a><span class="lineno"> 2492</span> </div>
<div class="line"><a id="l02493" name="l02493"></a><span class="lineno"> 2493</span>  <span class="comment">// Free the raw buffer at location to_delete; which we know is m_buf_sz `value_type`s long.</span></div>
<div class="line"><a id="l02494" name="l02494"></a><span class="lineno"> 2494</span>  <a class="code hl_variable" href="classflow_1_1util_1_1Basic__blob.html#ac7478166f4244b068a8793dc90b1f9e4">m_alloc_raw</a>-&gt;deallocate(to_delete, m_buf_sz);</div>
<div class="line"><a id="l02495" name="l02495"></a><span class="lineno"> 2495</span>}</div>
<div class="line"><a id="l02496" name="l02496"></a><span class="lineno"> 2496</span> </div>
<div class="line"><a id="l02497" name="l02497"></a><span class="lineno"> 2497</span>} <span class="comment">// namespace flow::util</span></div>
<div class="ttc" id="ablob__fwd_8hpp_html"><div class="ttname"><a href="blob__fwd_8hpp.html">blob_fwd.hpp</a></div></div>
<div class="ttc" id="aclassflow_1_1log_1_1Logger_html"><div class="ttname"><a href="classflow_1_1log_1_1Logger.html">flow::log::Logger</a></div><div class="ttdoc">Interface that the user should implement, passing the implementing Logger into logging classes (Flow'...</div><div class="ttdef"><b>Definition:</b> <a href="log_8hpp_source.html#l01280">log.hpp:1284</a></div></div>
<div class="ttc" id="aclassflow_1_1log_1_1Logger_html_ac8a2e7a33fe3fbc0c29ead62ed98c022"><div class="ttname"><a href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">flow::log::Logger::should_log</a></div><div class="ttdeci">virtual bool should_log(Sev sev, const Component &amp;component) const =0</div><div class="ttdoc">Given attributes of a hypothetical message that would be logged, return true if that message should b...</div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_1_1Deleter__raw_html"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html">flow::util::Basic_blob::Deleter_raw</a></div><div class="ttdoc">Internal deleter functor used if and only if S_IS_VANILLA_ALLOC is false and therefore only with Buf_...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01165">basic_blob.hpp:1166</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_1_1Deleter__raw_html_a0152dc5043d6375124456f71d961988c"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a0152dc5043d6375124456f71d961988c">flow::util::Basic_blob::Deleter_raw::pointer</a></div><div class="ttdeci">Pointer_raw pointer</div><div class="ttdoc">For boost::interprocess::shared_ptr and unique_ptr compliance (hence the irregular capitalization).</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01179">basic_blob.hpp:1179</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_1_1Deleter__raw_html_a145ea5595e461bd93bd6e585a67516e6"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a145ea5595e461bd93bd6e585a67516e6">flow::util::Basic_blob::Deleter_raw::Deleter_raw</a></div><div class="ttdeci">Deleter_raw()</div><div class="ttdoc">Default ctor: Must never be invoked; suitable only for a null smart-pointer.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02481">basic_blob.hpp:2481</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_1_1Deleter__raw_html_a2483f07aa6cf4ddb96309c4aa2eec00d"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a2483f07aa6cf4ddb96309c4aa2eec00d">flow::util::Basic_blob::Deleter_raw::m_buf_sz</a></div><div class="ttdeci">size_type m_buf_sz</div><div class="ttdoc">See ctor and operator()(): the size of the buffer to deallocate.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01236">basic_blob.hpp:1236</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_1_1Deleter__raw_html_a2b946cc7c51563ef74d1d47ebfad53c2"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a2b946cc7c51563ef74d1d47ebfad53c2">flow::util::Basic_blob::Deleter_raw::m_alloc_raw</a></div><div class="ttdeci">std::optional&lt; Allocator_raw &gt; m_alloc_raw</div><div class="ttdoc">See ctor: the allocator that operator()() shall use to deallocate.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01233">basic_blob.hpp:1233</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_1_1Deleter__raw_html_a83887b57f8a78c0224fd7563210e94ec"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#a83887b57f8a78c0224fd7563210e94ec">flow::util::Basic_blob::Deleter_raw::operator()</a></div><div class="ttdeci">void operator()(Pointer_raw to_delete)</div><div class="ttdoc">Deallocates using Allocator_raw::deallocate(), passing-in the supplied pointer (to value_type) to_del...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02489">basic_blob.hpp:2489</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_1_1Deleter__raw_html_ad45a273758a0fc0bd81ab36edc9d8217"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob_1_1Deleter__raw.html#ad45a273758a0fc0bd81ab36edc9d8217">flow::util::Basic_blob::Deleter_raw::Pointer_raw</a></div><div class="ttdeci">typename std::allocator_traits&lt; Allocator_raw &gt;::pointer Pointer_raw</div><div class="ttdoc">Short-hand for the allocator's pointer type, pointing to Basic_blob::value_type.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01176">basic_blob.hpp:1176</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html">flow::util::Basic_blob</a></div><div class="ttdoc">A hand-optimized and API-tweaked replacement for vector&lt;uint8_t&gt;, i.e., buffer of bytes inside an all...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00246">basic_blob.hpp:247</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a0044410b7d1f541978a309f02b2739d3"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a0044410b7d1f541978a309f02b2739d3">flow::util::Basic_blob::share</a></div><div class="ttdeci">Basic_blob share(log::Logger *logger_ptr=nullptr) const</div><div class="ttdoc">Applicable to !zero() blobs, this returns an identical Basic_blob that shares (co-owns) *this allocat...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01673">basic_blob.hpp:1673</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a151d35b3c35219089d53061503841b75"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a151d35b3c35219089d53061503841b75">flow::util::Basic_blob::operator=</a></div><div class="ttdeci">Basic_blob &amp; operator=(Basic_blob &amp;&amp;moved_src)</div><div class="ttdoc">Move assignment operator (no logging): equivalent to assign(std::move(moved_src), nullptr).</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01599">basic_blob.hpp:1599</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a198eb271d009f153cae041ba1948e945"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a198eb271d009f153cae041ba1948e945">flow::util::Basic_blob::derefable_iterator</a></div><div class="ttdeci">bool derefable_iterator(Const_iterator it) const</div><div class="ttdoc">Returns true if and only if the given iterator points to an element within this blob's size() element...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02438">basic_blob.hpp:2438</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a1a64646d656ec125fa8973ccf843c1be"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a1a64646d656ec125fa8973ccf843c1be">flow::util::Basic_blob::zero</a></div><div class="ttdeci">bool zero() const</div><div class="ttdoc">Returns false if a buffer is allocated and owned; true otherwise.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01866">basic_blob.hpp:1866</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a1dfd46fca324a6b80934b9230c2f2bb4"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a1dfd46fca324a6b80934b9230c2f2bb4">flow::util::Basic_blob::begin</a></div><div class="ttdeci">Const_iterator begin() const</div><div class="ttdoc">Equivalent to const_begin().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02390">basic_blob.hpp:2390</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a1f2d99a5b487a454af627e8e33738abf"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a1f2d99a5b487a454af627e8e33738abf">flow::util::Basic_blob::m_capacity</a></div><div class="ttdeci">size_type m_capacity</div><div class="ttdoc">See capacity(); but m_capacity is meaningless (and containing unknown value) if !m_buf_ptr (i....</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01410">basic_blob.hpp:1410</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a2bd3cb0b6b3f304fb6fb771c1b76ec66"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a2bd3cb0b6b3f304fb6fb771c1b76ec66">flow::util::Basic_blob::mutable_buffer</a></div><div class="ttdeci">boost::asio::mutable_buffer mutable_buffer()</div><div class="ttdoc">Same as const_buffer() but the returned view is mutable.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02458">basic_blob.hpp:2458</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a2e4aa425939071a4fb313d3237987226"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a2e4aa425939071a4fb313d3237987226">flow::util::Basic_blob::share_after_split_equally</a></div><div class="ttdeci">void share_after_split_equally(size_type size, bool headless_pool, Emit_blob_func &amp;&amp;emit_blob_func, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Identical to successively performing share_after_split_left(size) until this-&gt;empty() == true; the re...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01780">basic_blob.hpp:1780</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a30b8db540e6d8e6a0b6200c17cf45b60"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a30b8db540e6d8e6a0b6200c17cf45b60">flow::util::Basic_blob::resize</a></div><div class="ttdeci">void resize(size_type size, size_type start_or_unchanged=S_UNCHANGED, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Guarantees post-condition size() == size and start() == start; no values in pre-call range [begin(),...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02051">basic_blob.hpp:2051</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a30fe0a61f8b83e7588bdc4a88dbaabae"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a30fe0a61f8b83e7588bdc4a88dbaabae">flow::util::Basic_blob::Buf_ptr</a></div><div class="ttdeci">std::conditional_t&lt; S_IS_VANILLA_ALLOC, std::conditional_t&lt; S_SHARING, boost::shared_ptr&lt; value_type[]&gt;, boost::movelib::unique_ptr&lt; value_type[]&gt; &gt;, std::conditional_t&lt; S_SHARING, boost::interprocess::shared_ptr&lt; value_type, Allocator_raw, Deleter_raw &gt;, boost::movelib::unique_ptr&lt; value_type, Deleter_raw &gt; &gt; &gt; Buf_ptr</div><div class="ttdoc">The smart-pointer type used for m_buf_ptr; a custom-allocator-and-SHM-friendly impl and parameterizat...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01319">basic_blob.hpp:1326</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a3568f40cab930beabf5bd831489d610a"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a3568f40cab930beabf5bd831489d610a">flow::util::Basic_blob::Basic_blob</a></div><div class="ttdeci">Basic_blob(const Basic_blob &amp;src, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Copy constructor, constructing a blob logically equal to src.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01441">basic_blob.hpp:1441</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a3707ab8d2693a394c661b742d2626d4e"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a3707ab8d2693a394c661b742d2626d4e">flow::util::Basic_blob::swap</a></div><div class="ttdeci">void swap(Basic_blob &amp;other, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Swaps the contents of this structure and other, or no-op if this == &amp;other.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01642">basic_blob.hpp:1642</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a3e21c26d61b50e019987097f7779ed51"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a3e21c26d61b50e019987097f7779ed51">flow::util::Basic_blob::Const_iterator</a></div><div class="ttdeci">value_type const * Const_iterator</div><div class="ttdoc">Type for iterator pointing into an immutable structure of this type.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00264">basic_blob.hpp:264</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a4581e779dace3d64fe4098eb0a7dbeb2"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a4581e779dace3d64fe4098eb0a7dbeb2">flow::util::Basic_blob::data</a></div><div class="ttdeci">value_type * data()</div><div class="ttdoc">Equivalent to begin().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02425">basic_blob.hpp:2425</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a45b5f98e106d0cd36956063cd859d3c6"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a45b5f98e106d0cd36956063cd859d3c6">flow::util::Basic_blob::m_buf_ptr</a></div><div class="ttdeci">Buf_ptr m_buf_ptr</div><div class="ttdoc">Pointer to currently allocated buffer of size m_capacity; null if and only if zero() == true.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01407">basic_blob.hpp:1407</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a477ff0db26f79989d75da4dbe4bf4982"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a477ff0db26f79989d75da4dbe4bf4982">flow::util::Basic_blob::Basic_blob</a></div><div class="ttdeci">Basic_blob(Basic_blob &amp;&amp;moved_src, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Move constructor, constructing a blob exactly internally equal to pre-call moved_src,...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01454">basic_blob.hpp:1454</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a49046a070b040ca17ca9062ac291a6dd"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a49046a070b040ca17ca9062ac291a6dd">flow::util::Basic_blob::erase</a></div><div class="ttdeci">Iterator erase(Const_iterator first, Const_iterator past_last)</div><div class="ttdoc">Performs the minimal number of operations to make range [begin(), end()) unchanged except for lacking...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02263">basic_blob.hpp:2263</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a4939ea2f0c76ec448cdc12275ce17f33"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a4939ea2f0c76ec448cdc12275ce17f33">flow::util::Basic_blob::assign_copy</a></div><div class="ttdeci">size_type assign_copy(const boost::asio::const_buffer &amp;src, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Replaces logical contents with a copy of the given non-overlapping area anywhere in memory.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02139">basic_blob.hpp:2139</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a49d05eed39be69ceec235fe3403b16b9"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a49d05eed39be69ceec235fe3403b16b9">flow::util::Basic_blob::back</a></div><div class="ttdeci">value_type &amp; back()</div><div class="ttdoc">Returns reference to mutable last element.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02323">basic_blob.hpp:2323</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a527a63b2de0a165bb63296935aee954c"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a527a63b2de0a165bb63296935aee954c">flow::util::Basic_blob::const_iterator</a></div><div class="ttdeci">Const_iterator const_iterator</div><div class="ttdoc">For container compliance (hence the irregular capitalization): Const_iterator type.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00282">basic_blob.hpp:282</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a614d9cd750d8db928b4d1e045ef15c56"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a614d9cd750d8db928b4d1e045ef15c56">flow::util::Basic_blob::difference_type</a></div><div class="ttdeci">std::ptrdiff_t difference_type</div><div class="ttdoc">Type for difference of size_types.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00258">basic_blob.hpp:258</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a61880291749335246f60fde4387f7ad6"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a61880291749335246f60fde4387f7ad6">flow::util::Basic_blob::end</a></div><div class="ttdeci">Iterator end()</div><div class="ttdoc">Returns pointer one past mutable last element; empty() is possible.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02383">basic_blob.hpp:2383</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a625734b39e0e3317aa321b6f8569f334"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a625734b39e0e3317aa321b6f8569f334">flow::util::Basic_blob::Basic_blob</a></div><div class="ttdeci">Basic_blob(size_type size, log::Logger *logger_ptr=nullptr, const Allocator_raw &amp;alloc_raw=Allocator_raw{})</div><div class="ttdoc">Constructs blob with size() and capacity() equal to the given size, and start() == 0.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01432">basic_blob.hpp:1433</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a62da4400fbde6c186fb989f55248e3d2"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a62da4400fbde6c186fb989f55248e3d2">flow::util::Basic_blob::clear</a></div><div class="ttdeci">void clear()</div><div class="ttdoc">Equivalent to resize(0, start()).</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02103">basic_blob.hpp:2103</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a64ea173065830ef1a744458a7d05b833"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a64ea173065830ef1a744458a7d05b833">flow::util::Basic_blob::start</a></div><div class="ttdeci">size_type start() const</div><div class="ttdoc">Returns the offset between begin() and the start of the internally allocated buffer.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01848">basic_blob.hpp:1848</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a669252f9a78f516dfeaf964987078255"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a669252f9a78f516dfeaf964987078255">flow::util::Basic_blob::cbegin</a></div><div class="ttdeci">Const_iterator cbegin() const</div><div class="ttdoc">Synonym of const_begin().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02397">basic_blob.hpp:2397</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a67db182946127383fb48d6a1afbdca90"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a67db182946127383fb48d6a1afbdca90">flow::util::Basic_blob::S_SHARING</a></div><div class="ttdeci">static constexpr bool S_SHARING</div><div class="ttdoc">Value of template parameter S_SHARING_ALLOWED (for generic programming).</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00287">basic_blob.hpp:287</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a6c0635640d16084eb975a9fb97f96aab"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a6c0635640d16084eb975a9fb97f96aab">flow::util::Basic_blob::share_after_split_left</a></div><div class="ttdeci">Basic_blob share_after_split_left(size_type size, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Applicable to !zero() blobs, this shifts this-&gt;begin() by size to the right without changing end(); a...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01702">basic_blob.hpp:1702</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a719e5c04e4bdc65c31976fc385fd7f24"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a719e5c04e4bdc65c31976fc385fd7f24">flow::util::Basic_blob::capacity</a></div><div class="ttdeci">size_type capacity() const</div><div class="ttdoc">Returns the number of elements in the internally allocated buffer, which is 1 or more; or 0 if no buf...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01860">basic_blob.hpp:1860</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a72b010e5051889dd4732facb0b0d2e12"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a72b010e5051889dd4732facb0b0d2e12">flow::util::Basic_blob::reference</a></div><div class="ttdeci">value_type &amp; reference</div><div class="ttdoc">For container compliance (hence the irregular capitalization): reference to element.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00276">basic_blob.hpp:276</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a72eda661d71306c2fbd0422993922309"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a72eda661d71306c2fbd0422993922309">flow::util::Basic_blob::operator=</a></div><div class="ttdeci">Basic_blob &amp; operator=(const Basic_blob &amp;src)</div><div class="ttdoc">Copy assignment operator (no logging): equivalent to assign(src, nullptr).</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01547">basic_blob.hpp:1547</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a73e09b11e0067730db64f1fac7620a04"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a73e09b11e0067730db64f1fac7620a04">flow::util::Basic_blob::valid_iterator</a></div><div class="ttdeci">bool valid_iterator(Const_iterator it) const</div><div class="ttdoc">Returns true if and only if: this-&gt;derefable_iterator(it) || (it == this-&gt;const_end()).</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02431">basic_blob.hpp:2431</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a75d4c0a1e530596982a3b5d3e0ff91e6"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a75d4c0a1e530596982a3b5d3e0ff91e6">flow::util::Basic_blob::const_data</a></div><div class="ttdeci">value_type const * const_data() const</div><div class="ttdoc">Equivalent to const_begin().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02418">basic_blob.hpp:2418</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a7667397ae554e4a9dcb9a3bf1bf33eb8"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a7667397ae554e4a9dcb9a3bf1bf33eb8">flow::util::Basic_blob::S_UNCHANGED</a></div><div class="ttdeci">static constexpr size_type S_UNCHANGED</div><div class="ttdoc">Special value indicating an unchanged size_type value; such as in resize().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00290">basic_blob.hpp:290</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a77785988abe56d62dacf42ec6a733713"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a77785988abe56d62dacf42ec6a733713">flow::util::Basic_blob::assign</a></div><div class="ttdeci">Basic_blob &amp; assign(Basic_blob &amp;&amp;moved_src, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Move assignment.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01554">basic_blob.hpp:1554</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a797741a0a5c95b13b36f356ae8d397e8"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a797741a0a5c95b13b36f356ae8d397e8">flow::util::Basic_blob::empty</a></div><div class="ttdeci">bool empty() const</div><div class="ttdoc">Returns size() == 0.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01854">basic_blob.hpp:1854</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a7c99b053ce77cd0573d882e194908e49"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a7c99b053ce77cd0573d882e194908e49">flow::util::Basic_blob::const_back</a></div><div class="ttdeci">const value_type &amp; const_back() const</div><div class="ttdoc">Returns reference to immutable last element.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02307">basic_blob.hpp:2307</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a8b5a94572c51f89991987ca9f5bcf2b2"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a8b5a94572c51f89991987ca9f5bcf2b2">flow::util::Basic_blob::const_reference</a></div><div class="ttdeci">const value_type &amp; const_reference</div><div class="ttdoc">For container compliance (hence the irregular capitalization): reference to const element.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00278">basic_blob.hpp:278</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a8c04d217b83800f818c794da17dc8e4b"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a8c04d217b83800f818c794da17dc8e4b">flow::util::Basic_blob::size</a></div><div class="ttdeci">size_type size() const</div><div class="ttdoc">Returns number of elements stored, namely end() - begin().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01842">basic_blob.hpp:1842</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a90859b0e130bef705a2e556ccb27df53"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a90859b0e130bef705a2e556ccb27df53">flow::util::Basic_blob::const_front</a></div><div class="ttdeci">const value_type &amp; const_front() const</div><div class="ttdoc">Returns reference to immutable first element.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02299">basic_blob.hpp:2299</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a9113cfc8160e93a0e0fa45de8058b858"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a9113cfc8160e93a0e0fa45de8058b858">flow::util::Basic_blob::emplace_copy</a></div><div class="ttdeci">Iterator emplace_copy(Const_iterator dest, const boost::asio::const_buffer &amp;src, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Copies src buffer directly onto equally sized area within *this at location dest; *this must have suf...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02159">basic_blob.hpp:2159</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a92215c61d9e3ca83bdbfa6b078b72dc9"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a92215c61d9e3ca83bdbfa6b078b72dc9">flow::util::Basic_blob::share_after_split_equally_impl</a></div><div class="ttdeci">void share_after_split_equally_impl(size_type size, bool headless_pool, Emit_blob_func &amp;&amp;emit_blob_func, log::Logger *logger_ptr, Share_after_split_left_func &amp;&amp;share_after_split_left_func)</div><div class="ttdoc">Impl of share_after_split_equally() but capable of emitting not just *this type (Basic_blob&lt;....</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01751">basic_blob.hpp:1752</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a93b5764b185d0a1a1d143211e39b2de1"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a93b5764b185d0a1a1d143211e39b2de1">flow::util::Basic_blob::Iterator</a></div><div class="ttdeci">value_type * Iterator</div><div class="ttdoc">Type for iterator pointing into a mutable structure of this type.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00261">basic_blob.hpp:261</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a98a489088e29d5d4b82b0498c8e210f8"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a98a489088e29d5d4b82b0498c8e210f8">flow::util::Basic_blob::front</a></div><div class="ttdeci">const value_type &amp; front() const</div><div class="ttdoc">Equivalent to const_front().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02331">basic_blob.hpp:2331</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a9b61c80d3df1c53583362ec15cdbb0b6"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a9b61c80d3df1c53583362ec15cdbb0b6">flow::util::Basic_blob::end</a></div><div class="ttdeci">Const_iterator end() const</div><div class="ttdoc">Equivalent to const_end().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02404">basic_blob.hpp:2404</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a9c3497d662be650e7a560eb7a703acc1"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a9c3497d662be650e7a560eb7a703acc1">flow::util::Basic_blob::start_past_prefix_inc</a></div><div class="ttdeci">void start_past_prefix_inc(difference_type prefix_size_inc)</div><div class="ttdoc">Like start_past_prefix() but shifts the current prefix position by the given incremental value (posit...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02096">basic_blob.hpp:2096</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a9c8a51530bc17f779215970f3097a1f2"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a9c8a51530bc17f779215970f3097a1f2">flow::util::Basic_blob::iterator_sans_const</a></div><div class="ttdeci">Iterator iterator_sans_const(Const_iterator it)</div><div class="ttdoc">Returns iterator-to-mutable equivalent to given iterator-to-immutable.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02446">basic_blob.hpp:2446</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_a9daa427a42c8a8c24b585f96c37d277a"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#a9daa427a42c8a8c24b585f96c37d277a">flow::util::Basic_blob::begin</a></div><div class="ttdeci">Iterator begin()</div><div class="ttdoc">Returns pointer to mutable first element; or end() if empty().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02352">basic_blob.hpp:2352</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_aa025a04ef0a19aa2065cab61a2b3a92c"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#aa025a04ef0a19aa2065cab61a2b3a92c">flow::util::Basic_blob::share_after_split_equally_emit_seq</a></div><div class="ttdeci">void share_after_split_equally_emit_seq(size_type size, bool headless_pool, Blob_container *out_blobs, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">share_after_split_equally() wrapper that places Basic_blobs into the given container via push_back().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01793">basic_blob.hpp:1794</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_aa2484d717fde243f6118ac4b0312df87"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#aa2484d717fde243f6118ac4b0312df87">flow::util::Basic_blob::sub_copy</a></div><div class="ttdeci">Const_iterator sub_copy(Const_iterator src, const boost::asio::mutable_buffer &amp;dest, log::Logger *logger_ptr=nullptr) const</div><div class="ttdoc">The opposite of emplace_copy() in every way, copying a sub-blob onto a target memory area.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02221">basic_blob.hpp:2221</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_aaa7bc2f80b4e46a18f04911954e2b3e7"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#aaa7bc2f80b4e46a18f04911954e2b3e7">flow::util::Basic_blob::reserve</a></div><div class="ttdeci">void reserve(size_type capacity, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Ensures that an internal buffer of at least capacity elements is allocated and owned; disallows growi...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01872">basic_blob.hpp:1872</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_aae53d36a27090ef5da931bc17d4f2bcd"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#aae53d36a27090ef5da931bc17d4f2bcd">flow::util::Basic_blob::m_start</a></div><div class="ttdeci">size_type m_start</div><div class="ttdoc">See start(); but m_start is meaningless (and containing unknown value) if !m_buf_ptr (i....</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01413">basic_blob.hpp:1413</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ab73d1c26268670495dda161f95d33ec1"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ab73d1c26268670495dda161f95d33ec1">flow::util::Basic_blob::const_pointer</a></div><div class="ttdeci">Const_iterator const_pointer</div><div class="ttdoc">For container compliance (hence the irregular capitalization): pointer to const element.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00274">basic_blob.hpp:274</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ab79d366c55643022eaf9e0d7378165d7"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ab79d366c55643022eaf9e0d7378165d7">flow::util::Basic_blob::S_IS_VANILLA_ALLOC</a></div><div class="ttdeci">static constexpr bool S_IS_VANILLA_ALLOC</div><div class="ttdoc">true if Allocator_raw underlying allocator template is simply std::allocator; false otherwise.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00330">basic_blob.hpp:330</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_abbd8243321a70378f27b551ff8082619"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#abbd8243321a70378f27b551ff8082619">flow::util::Basic_blob::Basic_blob</a></div><div class="ttdeci">Basic_blob(const Allocator_raw &amp;alloc_raw=Allocator_raw{})</div><div class="ttdoc">Constructs blob with zero() == true.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01425">basic_blob.hpp:1425</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_abe7ea8c6aa0a7b043129fca8eacaedad"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#abe7ea8c6aa0a7b043129fca8eacaedad">flow::util::Basic_blob::front</a></div><div class="ttdeci">value_type &amp; front()</div><div class="ttdoc">Returns reference to mutable first element.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02315">basic_blob.hpp:2315</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ac008b60f7fe4253be9527436b0661dcc"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ac008b60f7fe4253be9527436b0661dcc">flow::util::Basic_blob::m_size</a></div><div class="ttdeci">size_type m_size</div><div class="ttdoc">See size(); but m_size is meaningless (and containing unknown value) if !m_buf_ptr (i....</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01416">basic_blob.hpp:1416</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ac10980e7748d8198fe831666254d864d"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ac10980e7748d8198fe831666254d864d">flow::util::Basic_blob::back</a></div><div class="ttdeci">const value_type &amp; back() const</div><div class="ttdoc">Equivalent to const_back().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02338">basic_blob.hpp:2338</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ac511ddaa3fb453888524cedba39c36ef"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ac511ddaa3fb453888524cedba39c36ef">flow::util::Basic_blob::const_begin</a></div><div class="ttdeci">Const_iterator const_begin() const</div><div class="ttdoc">Returns pointer to immutable first element; or end() if empty().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02345">basic_blob.hpp:2345</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ac7478166f4244b068a8793dc90b1f9e4"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ac7478166f4244b068a8793dc90b1f9e4">flow::util::Basic_blob::m_alloc_raw</a></div><div class="ttdeci">Allocator_raw m_alloc_raw</div><div class="ttdoc">See get_allocator(): copy of the allocator supplied by the user (though, if Allocator_raw is stateles...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01391">basic_blob.hpp:1391</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_acf07a3d48fd3b216ed2a08a088b7ba6a"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#acf07a3d48fd3b216ed2a08a088b7ba6a">flow::util::Basic_blob::share_after_split_equally_emit_ptr_seq</a></div><div class="ttdeci">void share_after_split_equally_emit_ptr_seq(size_type size, bool headless_pool, Blob_ptr_container *out_blobs, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">share_after_split_equally() wrapper that places Ptr&lt;Basic_blob&gt;s into the given container via push_ba...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01807">basic_blob.hpp:1807</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_acf4d5acf2bdde5e602dd2f9d305adebf"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#acf4d5acf2bdde5e602dd2f9d305adebf">flow::util::Basic_blob::make_zero</a></div><div class="ttdeci">void make_zero(log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Guarantees post-condition zero() == true by dropping *this ownership of the allocated internal buffer...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02111">basic_blob.hpp:2111</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ad65bfdec2d39f4ccce6c311226b78c5b"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ad65bfdec2d39f4ccce6c311226b78c5b">flow::util::Basic_blob::S_LOG_COMPONENT</a></div><div class="ttdeci">static constexpr Flow_log_component S_LOG_COMPONENT</div><div class="ttdoc">Our flow::log::Component.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01111">basic_blob.hpp:1111</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ada9e80920dcc3d51c229db98a9d62ac6"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ada9e80920dcc3d51c229db98a9d62ac6">flow::util::Basic_blob::cend</a></div><div class="ttdeci">Const_iterator cend() const</div><div class="ttdoc">Synonym of const_end().</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02411">basic_blob.hpp:2411</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_adc0bb760b5f2f36147d128e2e5fbe95f"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#adc0bb760b5f2f36147d128e2e5fbe95f">flow::util::Basic_blob::swap_impl</a></div><div class="ttdeci">void swap_impl(Basic_blob &amp;other, log::Logger *logger_ptr)</div><div class="ttdoc">The body of swap(), except for the part that swaps (or decides not to swap) m_alloc_raw.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01605">basic_blob.hpp:1605</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_adc55075d7e257e08058eabf5fe06ee33"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#adc55075d7e257e08058eabf5fe06ee33">flow::util::Basic_blob::pointer</a></div><div class="ttdeci">Iterator pointer</div><div class="ttdoc">For container compliance (hence the irregular capitalization): pointer to element.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00272">basic_blob.hpp:272</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ae2089286c63766445b3bf40422eb17db"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ae2089286c63766445b3bf40422eb17db">flow::util::Basic_blob::Allocator_raw</a></div><div class="ttdeci">Allocator Allocator_raw</div><div class="ttdoc">Short-hand for the allocator type specified at compile-time. Its element type is our value_type.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00267">basic_blob.hpp:267</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ae4f1d8c42aea63ba4f127cb7ed5776d6"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ae4f1d8c42aea63ba4f127cb7ed5776d6">flow::util::Basic_blob::const_end</a></div><div class="ttdeci">Const_iterator const_end() const</div><div class="ttdoc">Returns pointer one past immutable last element; empty() is possible.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02376">basic_blob.hpp:2376</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ae5feeeb171724712ace3ec667fc0a3e2"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ae5feeeb171724712ace3ec667fc0a3e2">flow::util::Basic_blob::iterator</a></div><div class="ttdeci">Iterator iterator</div><div class="ttdoc">For container compliance (hence the irregular capitalization): Iterator type.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00280">basic_blob.hpp:280</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_ae9fc395523fae83128888d9bb1c90726"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#ae9fc395523fae83128888d9bb1c90726">flow::util::Basic_blob::~Basic_blob</a></div><div class="ttdeci">~Basic_blob()</div><div class="ttdoc">Destructor that drops *this ownership of the allocated internal buffer if any, as by make_zero(); if ...</div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_aeb9b64885b78263048d406ec34907ecf"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#aeb9b64885b78263048d406ec34907ecf">flow::util::Basic_blob::value_type</a></div><div class="ttdeci">uint8_t value_type</div><div class="ttdoc">Short-hand for values, which in this case are unsigned bytes.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00252">basic_blob.hpp:252</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_aedd12dc6003934e156e3dc100e7c193e"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#aedd12dc6003934e156e3dc100e7c193e">flow::util::Basic_blob::share_after_split_right</a></div><div class="ttdeci">Basic_blob share_after_split_right(size_type size, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Identical to share_after_split_left(), except this-&gt;end() shifts by size to the left (instead of this...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01726">basic_blob.hpp:1726</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_af32359d0bd98f378c7397a7c86e6e66d"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#af32359d0bd98f378c7397a7c86e6e66d">flow::util::Basic_blob::get_allocator</a></div><div class="ttdeci">Allocator_raw get_allocator() const</div><div class="ttdoc">Returns a copy of the internally cached Allocator_raw as set by a constructor or assign() or assignme...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02465">basic_blob.hpp:2465</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_af98832169c8e46d84f6c06987a3670e3"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#af98832169c8e46d84f6c06987a3670e3">flow::util::Basic_blob::start_past_prefix</a></div><div class="ttdeci">void start_past_prefix(size_type prefix_size)</div><div class="ttdoc">Restructures blob to consist of an internally allocated buffer and a [begin(), end) range starting at...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02086">basic_blob.hpp:2086</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_af9b27f4b460a0fa8a9c9638174a9433a"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#af9b27f4b460a0fa8a9c9638174a9433a">flow::util::Basic_blob::size_type</a></div><div class="ttdeci">std::size_t size_type</div><div class="ttdoc">Type for index into blob or length of blob or sub-blob.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00255">basic_blob.hpp:255</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_afbb4e2420be2f8ca0dc8c4fb70feb8ea"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#afbb4e2420be2f8ca0dc8c4fb70feb8ea">flow::util::Basic_blob::const_buffer</a></div><div class="ttdeci">boost::asio::const_buffer const_buffer() const</div><div class="ttdoc">Convenience accessor returning an immutable boost.asio buffer &quot;view&quot; into the entirety of the blob.</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l02452">basic_blob.hpp:2452</a></div></div>
<div class="ttc" id="aclassflow_1_1util_1_1Basic__blob_html_aff44a959c238ea8aae3230c0b834d558"><div class="ttname"><a href="classflow_1_1util_1_1Basic__blob.html#aff44a959c238ea8aae3230c0b834d558">flow::util::Basic_blob::assign</a></div><div class="ttdeci">Basic_blob &amp; assign(const Basic_blob &amp;src, log::Logger *logger_ptr=nullptr)</div><div class="ttdoc">Copy assignment: assuming (this != &amp;src) &amp;&amp; (!blobs_sharing(*this, src)), makes *this logically equal...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01468">basic_blob.hpp:1468</a></div></div>
<div class="ttc" id="alog_8hpp_html"><div class="ttname"><a href="log_8hpp.html">log.hpp</a></div></div>
<div class="ttc" id="alog_8hpp_html_a6b3b2cd7ddabf90a7c6ccd104a042cc6"><div class="ttname"><a href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a></div><div class="ttdeci">#define FLOW_LOG_TRACE_WITHOUT_CHECKING(ARG_stream_fragment)</div><div class="ttdoc">Logs a TRACE message into flow::log::Logger *get_logger() with flow::log::Component get_log_component...</div><div class="ttdef"><b>Definition:</b> <a href="log_8hpp_source.html#l00354">log.hpp:354</a></div></div>
<div class="ttc" id="alog_8hpp_html_ae4b5d4fdd2eb052615620879dd74af95"><div class="ttname"><a href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a></div><div class="ttdeci">#define FLOW_LOG_SET_CONTEXT(ARG_logger_ptr, ARG_component_payload)</div><div class="ttdoc">For the rest of the block within which this macro is instantiated, causes all FLOW_LOG_....</div><div class="ttdef"><b>Definition:</b> <a href="log_8hpp_source.html#l00405">log.hpp:405</a></div></div>
<div class="ttc" id="alog_8hpp_html_affcf2e4c496ce3f42adf981669c623b8"><div class="ttname"><a href="log_8hpp.html#affcf2e4c496ce3f42adf981669c623b8">FLOW_LOG_TRACE</a></div><div class="ttdeci">#define FLOW_LOG_TRACE(ARG_stream_fragment)</div><div class="ttdoc">Logs a TRACE message into flow::log::Logger *get_logger() with flow::log::Component get_log_component...</div><div class="ttdef"><b>Definition:</b> <a href="log_8hpp_source.html#l00227">log.hpp:227</a></div></div>
<div class="ttc" id="anamespaceflow_1_1log_html_a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b"><div class="ttname"><a href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b">flow::log::Sev::S_TRACE</a></div><div class="ttdeci">@ S_TRACE</div><div class="ttdoc">Message indicates any condition that may occur with great frequency (thus verbose if logged).</div></div>
<div class="ttc" id="anamespaceflow_1_1util_html"><div class="ttname"><a href="namespaceflow_1_1util.html">flow::util</a></div><div class="ttdoc">Flow module containing miscellaneous general-use facilities that don't fit into any other Flow module...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l00028">basic_blob.hpp:29</a></div></div>
<div class="ttc" id="anamespaceflow_1_1util_html_a024ddda9acb2b66f2a1b35cdb0c016aa"><div class="ttname"><a href="namespaceflow_1_1util.html#a024ddda9acb2b66f2a1b35cdb0c016aa">flow::util::in_closed_open_range</a></div><div class="ttdeci">bool in_closed_open_range(T const &amp;min_val, T const &amp;val, T const &amp;max_val)</div><div class="ttdoc">Returns true if and only if the given value is within the given range, given as a [low,...</div><div class="ttdef"><b>Definition:</b> <a href="util_2util_8hpp_source.html#l00287">util.hpp:287</a></div></div>
<div class="ttc" id="anamespaceflow_1_1util_html_a71eaa4ab6a2673ed34fa8989c47a7bc0"><div class="ttname"><a href="namespaceflow_1_1util.html#a71eaa4ab6a2673ed34fa8989c47a7bc0">flow::util::swap</a></div><div class="ttdeci">void swap(Basic_blob&lt; Allocator, S_SHARING_ALLOWED &gt; &amp;blob1, Basic_blob&lt; Allocator, S_SHARING_ALLOWED &gt; &amp;blob2, log::Logger *logger_ptr)</div><div class="ttdoc">Equivalent to blob1.swap(blob2).</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01666">basic_blob.hpp:1666</a></div></div>
<div class="ttc" id="anamespaceflow_1_1util_html_ab10bc9e8bef148f875aa743fe0852743"><div class="ttname"><a href="namespaceflow_1_1util.html#ab10bc9e8bef148f875aa743fe0852743">flow::util::in_closed_range</a></div><div class="ttdeci">bool in_closed_range(T const &amp;min_val, T const &amp;val, T const &amp;max_val)</div><div class="ttdoc">Returns true if and only if the given value is within the given range, inclusive.</div><div class="ttdef"><b>Definition:</b> <a href="util_2util_8hpp_source.html#l00271">util.hpp:271</a></div></div>
<div class="ttc" id="anamespaceflow_1_1util_html_af567381736851969f6e8812c54404028"><div class="ttname"><a href="namespaceflow_1_1util.html#af567381736851969f6e8812c54404028">flow::util::blobs_sharing</a></div><div class="ttdeci">bool blobs_sharing(const Basic_blob&lt; Allocator, S_SHARING_ALLOWED &gt; &amp;blob1, const Basic_blob&lt; Allocator, S_SHARING_ALLOWED &gt; &amp;blob2)</div><div class="ttdoc">Returns true if and only if both given objects are not zero() == true, and they either co-own a commo...</div><div class="ttdef"><b>Definition:</b> <a href="basic__blob_8hpp_source.html#l01826">basic_blob.hpp:1826</a></div></div>
<div class="ttc" id="anamespaceflow_html_a3938730ab4b89daf13d027a5f620e7ce"><div class="ttname"><a href="namespaceflow.html#a3938730ab4b89daf13d027a5f620e7ce">flow::Flow_log_component</a></div><div class="ttdeci">Flow_log_component</div><div class="ttdoc">The flow::log::Component payload enumeration comprising various log components used by Flow's own int...</div><div class="ttdef"><b>Definition:</b> <a href="common_8hpp_source.html#l00637">common.hpp:638</a></div></div>
<div class="ttc" id="anamespaceflow_html_ae02da22c4a101eaab447511c905e4f32"><div class="ttname"><a href="namespaceflow.html#ae02da22c4a101eaab447511c905e4f32">flow::uint8_t</a></div><div class="ttdeci">unsigned char uint8_t</div><div class="ttdoc">Byte. Best way to represent a byte of binary data. This is 8 bits on all modern systems.</div><div class="ttdef"><b>Definition:</b> <a href="common_8hpp_source.html#l00391">common.hpp:391</a></div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Generated on Fri Mar 28 2025 22:55:35 for Flow by&#160;<a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.4
</small></address>
</body>
</html>
